{"text": "#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#ifdef USE_MULTITHREADING\n# include \n#endif\n\n#include \n#include \n#include \n#include \n\n#include \n#include // get_root_of_unity\n\n#include \n\nusing std::endl;\nusing namespace NTL;\n\nnamespace libutt {\n\n using random_bytes_engine = std::independent_bits_engine<\n std::default_random_engine, CHAR_BIT, unsigned char>;\n\n void initialize(unsigned char * randSeed, int size) {\n (void)randSeed; // TODO: initialize entropy source\n (void)size; // TODO: initialize entropy source\n\n // Apparently, libff logs some extra info when computing pairings\n libff::inhibit_profiling_info = true;\n\n // AB: We _info disables printing of information and _counters prevents tracking of profiling information. If we are using the code in parallel, disable both the logs.\n libff::inhibit_profiling_counters = true;\n\n // Initializes the default EC curve, so as to avoid \"surprises\"\n libff::default_ec_pp::init_public_params();\n\n // Initializes the NTL finite field\n ZZ p = conv (\"21888242871839275222246405745257275088548364400416034343698204186575808495617\");\n ZZ_p::init(p);\n\n NTL::SetSeed(randSeed, size);\n\n#ifdef USE_MULTITHREADING\n // NOTE: See https://stackoverflow.com/questions/11095309/openmp-set-num-threads-is-not-working\n loginfo << \"Using \" << getNumCores() << \" threads\" << endl;\n omp_set_dynamic(0); // Explicitly disable dynamic teams\n omp_set_num_threads(static_cast(getNumCores())); // Use 4 threads for all consecutive parallel regions\n#else\n //loginfo << \"NOT using multithreading\" << endl;\n#endif\n\n RangeProof::Params::initializeOmegas();\n }\n\n GT MultiPairingNaive(const std::vector& g1, const std::vector& g2) {\n assertEqual(g1.size(), g2.size());\n GT r = GT::one();\n for(size_t i = 0; i < g1.size(); i++) {\n r = r * ReducedPairing(g1[i], g2[i]);\n }\n return r;\n }\n \n GT MultiPairing(const std::vector& g1, const std::vector& g2) {\n assertEqual(g1.size(), g2.size());\n using G1_precomp = libff::default_ec_pp::G1_precomp_type;\n using G2_precomp = libff::default_ec_pp::G2_precomp_type;\n using Fqk = libff::default_ec_pp::Fqk_type; \n\n std::vector g1p;\n std::vector g2p;\n\n for(auto el : g1) {\n g1p.push_back(libff::default_ec_pp::precompute_G1(el));\n }\n \n for(auto el : g2) {\n g2p.push_back(libff::default_ec_pp::precompute_G2(el));\n }\n\n auto numDblMiller = g1.size() / 2;\n bool singleMiller = (g1.size() % 2 == 1);\n Fqk r = Fqk::one();\n for(size_t i = 0; i < numDblMiller; i++) {\n r = r * libff::default_ec_pp::double_miller_loop(\n g1p[2*i],\n g2p[2*i],\n g1p[2*i + 1],\n g2p[2*i + 1]\n );\n }\n\n if(singleMiller) {\n r = r * libff::default_ec_pp::miller_loop(\n g1p.back(),\n g2p.back()\n );\n }\n\n return libff::default_ec_pp::final_exponentiation(r);\n }\n\n Fr hashToField(const unsigned char * bytes, size_t len) {\n // hash bytes, but output a hex string not bytes\n std::string hex;\n picosha2::hash256_hex_string(bytes, bytes + len, hex);\n hex.pop_back(); // small enough for BN-P254 field\n\n // convert hex to mpz_t\n mpz_t rop;\n mpz_init(rop);\n mpz_set_str(rop, hex.c_str(), 16);\n\n // convert mpz_t to Fr\n Fr fr = libff::bigint(rop);\n mpz_clear(rop);\n\n return fr;\n }\n\n Fr hashToField(const std::string& message)\n {\n return hashToField(reinterpret_cast(message.c_str()), message.size());\n }\n\n size_t Fr_num_bytes() {\n const size_t assumedFieldSize = 32; // bytes\n\n#ifndef NDEBUG\n // make sure Fr's are actually 32 bytes\n Fr test = Fr::random_element();\n std::vector v = test.to_words();\n // a byte is 8 bits => 64 bits is 8 bytes => need 4 words in 'v'\n assertEqual(v.size(), 4);\n#endif\n\n return assumedFieldSize;\n }\n\n void Fr_serialize(const Fr& fr, unsigned char * bytes, size_t capacity) {\n std::vector words = fr.to_words();\n \n size_t wordSize = sizeof(uint64_t);\n \n if (capacity < wordSize * words.size()) {\n throw std::runtime_error(\"Need larger buffer to serialize Fr\");\n }\n\n for(auto& w : words) {\n std::memcpy(bytes, reinterpret_cast(&w), wordSize); \n bytes += wordSize;\n }\n }\n\n Fr Fr_deserialize(const unsigned char * bytes, size_t len) {\n Fr a;\n size_t wordSize = sizeof(uint64_t);\n size_t numWords = len / wordSize;\n std::vector words(numWords);\n assertEqual(words.size(), numWords);\n \n for(size_t i = 0; i < words.size(); i++) {\n uint64_t w;\n std::memcpy(reinterpret_cast(&w), bytes, wordSize);\n bytes += wordSize;\n words[i] = w;\n }\n\n a.from_words(words);\n\n return a;\n }\n\n AutoBuf frsToBytes(const std::vector& frs) {\n size_t frSize = Fr_num_bytes();\n\n AutoBuf buf(frSize * frs.size());\n\n for(size_t i = 0; i < frs.size(); i++)\n Fr_serialize(frs[i], buf.getBuf() + i * frSize, frSize);\n\n return buf;\n }\n\n std::vector bytesToFrs(const AutoBuf& buf) {\n std::vector frs;\n\n size_t frSize = Fr_num_bytes();\n size_t num = buf.size() / frSize;\n\n for(size_t i = 0; i < num; i++) {\n auto val = Fr_deserialize(buf.getBuf() + i*frSize, frSize);\n\n frs.push_back(val);\n }\n\n return frs;\n }\n\n void random_bytes(unsigned char * bytes, size_t len)\n {\n random_bytes_engine rbe;\n std::generate(bytes, bytes + len, std::ref(rbe));\n }\n\n std::vector random_field_elems(size_t num) {\n std::vector p(num);\n for (size_t i = 0; i < p.size(); i++) {\n p[i] = Fr::random_element();\n }\n return p;\n }\n\n size_t getNumCores() {\n static size_t numCores = std::thread::hardware_concurrency();\n if(numCores == 0)\n throw std::runtime_error(\"Could not get number of cores\");\n return numCores;\n }\n\n std::vector get_all_roots_of_unity(size_t n) {\n if(n < 1)\n throw std::runtime_error(\"Cannot get 0th root-of-unity\");\n\n size_t N = Utils::smallestPowerOfTwoAbove(n);\n\n // initialize array of roots of unity\n Fr omega = libff::get_root_of_unity(N);\n std::vector omegas(n);\n omegas[0] = Fr::one();\n\n if(n > 1) {\n omegas[1] = omega;\n for(size_t i = 2; i < n; i++) {\n omegas[i] = omega * omegas[i-1];\n }\n }\n\n return omegas;\n }\n\n //std::vector random_poly(size_t deg) {\n // return random_field_elems(deg+1);\n //}\n\n} // end of namespace libutt\n\nnamespace boost {\n\n std::size_t hash_value(const libutt::Fr& f)\n {\n size_t size;\n mpz_t rop;\n mpz_init(rop);\n f.as_bigint().to_mpz(rop);\n\n //char *s = mpz_get_str(NULL, 10, rop);\n //size = strlen(s);\n //auto h = boost::hash_range(s, s + size);\n\n //void (*freefunc)(void *, size_t);\n //mp_get_memory_functions(NULL, NULL, &freefunc);\n //freefunc(s, size);\n\n\n mpz_export(NULL, &size, 1, 1, 1, 0, rop);\n AutoBuf buf(static_cast(size));\n\n mpz_export(buf, &size, 1, 1, 1, 0, rop);\n auto h = boost::hash_range(buf, buf + buf.size());\n\n mpz_clear(rop);\n return h;\n }\n\n} // end of boost namespace\n", "meta": {"hexsha": "79511e65d369fdce6b37edc8ab7c66531359dc42", "size": 8394, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libutt/libutt/src/PolyCrypto.cpp", "max_stars_repo_name": "definitelyNotFBI/utt", "max_stars_repo_head_hexsha": "1695e3a1f81848e19b042cdc4db9cf1d263c26a9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "libutt/libutt/src/PolyCrypto.cpp", "max_issues_repo_name": "definitelyNotFBI/utt", "max_issues_repo_head_hexsha": "1695e3a1f81848e19b042cdc4db9cf1d263c26a9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "libutt/libutt/src/PolyCrypto.cpp", "max_forks_repo_name": "definitelyNotFBI/utt", "max_forks_repo_head_hexsha": "1695e3a1f81848e19b042cdc4db9cf1d263c26a9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.1458333333, "max_line_length": 175, "alphanum_fraction": 0.5773171313, "num_tokens": 2225, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6224593452091672, "lm_q2_score": 0.5621765008857982, "lm_q1q2_score": 0.34993201663335477}} {"text": "#include \"Weave.h\"\r\n#include \"topology_object.h\"\r\n#include \"face.h\"\r\n#include \"edge.h\"\r\n#include \"vertex.h\"\r\n#include \"logging.h\"\r\n#include \"object_store.h\"\r\n#include \"vector3d.h\"\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\nusing namespace std;\r\nusing namespace ci;\r\nusing namespace boost;\r\n\r\nTile::Tile(unsigned int num_vertices) {\r\n n = num_vertices;\r\n marked = -1;\r\n knotType=PLUS1;\r\n //knotType=TWIST1;\r\n visited=0; isCrv1Used=NO; isCrv2Used = NO;\r\n}\r\n\r\nTile::~Tile() { up.clear(); down.clear(); }\r\n\r\nVector3D Tile::trilinearInterpolation(float u,float v,float t)\r\n{\r\n Vector3D ret_val(0.0,0.0,0.0);\r\n ret_val += ( ((1-u)*(1-v)*(1-t))*(*up[0]) );\r\n ret_val += ( (u*(1-v)*(1-t))*(*up[1]) );\r\n ret_val += ( (u*v*(1-t))*(*up[2]) );\r\n ret_val += ( ((1-u)*v*(1-t))*(*up[3]) );\r\n\r\n ret_val += ( ((1-u)*(1-v)*t)*(*down[0]) );\r\n ret_val += ( (u*(1-v)*t)*(*down[1]) );\r\n ret_val += ( (u*v*t)*(*down[2]) );\r\n ret_val += ( ((1-u)*v*t)*(*down[3]) );\r\n return ret_val;\r\n}\r\n\r\nvoid Tile::generateCurvePoints()\r\n{\r\n /* Safety purposes clear both vector of points */\r\n curve1.clear();\r\n curve2.clear();\r\n Vector3D *tmp;\r\n tmp = new Vector3D(trilinearInterpolation(0.5,0.25,0.5));\r\n curve1.push_back(tmp);\r\n tmp = new Vector3D(trilinearInterpolation(0.5,0.5,0.75));\r\n curve1.push_back(tmp);\r\n tmp = new Vector3D(trilinearInterpolation(0.5,0.75,0.5));\r\n curve1.push_back(tmp);\r\n\r\n tmp = new Vector3D(trilinearInterpolation(0.25,0.5,0.5));\r\n curve2.push_back(tmp);\r\n tmp = new Vector3D(trilinearInterpolation(0.5,0.5,0.25));\r\n curve2.push_back(tmp);\r\n tmp = new Vector3D(trilinearInterpolation(0.75,0.5,0.5));\r\n curve2.push_back(tmp);\r\n}\r\n\r\nvoid Tile::generateTwist1Points()\r\n{\r\n /* A call to this function clears out any curve points\r\n *generated for PLUS1/PLUS2 with new twisted curves points */\r\n curve1.clear();\r\n curve2.clear();\r\n Vector3D *tmp;\r\n tmp = new Vector3D(trilinearInterpolation(0.5,0.25,0.75));\r\n curve1.push_back(tmp);\r\n tmp = new Vector3D(trilinearInterpolation(0.75,0.5,0.5));\r\n curve1.push_back(tmp);\r\n tmp = new Vector3D(trilinearInterpolation(0.25,0.75,0.25));\r\n curve1.push_back(tmp);\r\n\r\n tmp = new Vector3D(trilinearInterpolation(0.75,0.25,0.25));\r\n curve2.push_back(tmp);\r\n tmp = new Vector3D(trilinearInterpolation(0.25,0.5,0.5));\r\n curve2.push_back(tmp);\r\n tmp = new Vector3D(trilinearInterpolation(0.5,0.75,0.75));\r\n curve2.push_back(tmp);\r\n}\r\n\r\nvoid Tile::generateTwist2Points()\r\n{\r\n /* A call to this function clears out any curve points\r\n *generated for PLUS1/PLUS2 with new twisted curves points */\r\n curve1.clear();\r\n curve2.clear();\r\n Vector3D *tmp;\r\n tmp = new Vector3D(trilinearInterpolation(0.5,0.25,0.75));\r\n curve1.push_back(tmp);\r\n tmp = new Vector3D(trilinearInterpolation(0.25,0.5,0.5));\r\n curve1.push_back(tmp);\r\n tmp = new Vector3D(trilinearInterpolation(0.75,0.75,0.25));\r\n curve1.push_back(tmp);\r\n\r\n tmp = new Vector3D(trilinearInterpolation(0.25,0.25,0.25));\r\n curve2.push_back(tmp);\r\n tmp = new Vector3D(trilinearInterpolation(0.75,0.5,0.5));\r\n curve2.push_back(tmp);\r\n tmp = new Vector3D(trilinearInterpolation(0.5,0.75,0.75));\r\n curve2.push_back(tmp);\r\n}\r\n\r\nvoid Tile::swapCurveMidPoints()\r\n{\r\n int mid = curve1.size()/2;\r\n Vector3D *temp = curve1[mid];\r\n curve1[mid] = curve2[mid];\r\n curve2[mid] = temp;\r\n}\r\n\r\nvoid Tile::findCurveAndDirection(Vertex *end, Vertex *othEnd, bool &isCurve1, bool &isRev)\r\n{\r\n if( knotType == PLUS1 || knotType == PLUS2 ) {\r\n if( (actVerts[0] == end && actVerts[1] == othEnd) ||\r\n (actVerts[1] == end && actVerts[0] == othEnd) ) {\r\n isCurve1 = true;\r\n isRev = false;\r\n } else if( (actVerts[1] == end && actVerts[2] == othEnd) ||\r\n (actVerts[2] == end && actVerts[1] == othEnd) ) {\r\n isCurve1 = false;\r\n isRev = true;\r\n }else if( (actVerts[2] == end && actVerts[3] == othEnd) ||\r\n (actVerts[3] == end && actVerts[2] == othEnd) ) {\r\n isCurve1 = true;\r\n isRev = true;\r\n }else if( (actVerts[3] == end && actVerts[0] == othEnd) ||\r\n (actVerts[0] == end && actVerts[3] == othEnd) ) {\r\n isCurve1 = false;\r\n isRev = false;\r\n }\r\n } else if( knotType == TWIST1 ) {\r\n if( (actVerts[0] == end && actVerts[1] == othEnd) ||\r\n (actVerts[1] == end && actVerts[0] == othEnd) ) {\r\n isCurve1 = true;\r\n isRev = false;\r\n } else if( (actVerts[1] == end && actVerts[2] == othEnd) ||\r\n (actVerts[2] == end && actVerts[1] == othEnd) ) {\r\n isCurve1 = false;\r\n isRev = false;\r\n }else if( (actVerts[2] == end && actVerts[3] == othEnd) ||\r\n (actVerts[3] == end && actVerts[2] == othEnd) ) {\r\n isCurve1 = false;\r\n isRev = true;\r\n }else if( (actVerts[3] == end && actVerts[0] == othEnd) ||\r\n (actVerts[0] == end && actVerts[3] == othEnd) ) {\r\n isCurve1 = true;\r\n isRev = true;\r\n }\r\n } else if( knotType == TWIST2 ) {\r\n if( (actVerts[0] == end && actVerts[1] == othEnd) ||\r\n (actVerts[1] == end && actVerts[0] == othEnd) ) {\r\n isCurve1 = true;\r\n isRev = false;\r\n } else if( (actVerts[1] == end && actVerts[2] == othEnd) ||\r\n (actVerts[2] == end && actVerts[1] == othEnd) ) {\r\n isCurve1 = true;\r\n isRev = true;\r\n }else if( (actVerts[2] == end && actVerts[3] == othEnd) ||\r\n (actVerts[3] == end && actVerts[2] == othEnd) ) {\r\n isCurve1 = false;\r\n isRev = true;\r\n }else if( (actVerts[3] == end && actVerts[0] == othEnd) ||\r\n (actVerts[0] == end && actVerts[3] == othEnd) ) {\r\n isCurve1 = false;\r\n isRev = false;\r\n }\r\n }\r\n}\r\n\r\n\r\n\r\n\r\n\r\nstring Mesh::getOriginalFileName(string filename,string &path)\r\n{\r\n vector subStrs;\r\n char_separator sep(\"\\\\\");\r\n typedef tokenizer< boost::char_separator > Tokenizer;\r\n Tokenizer tok(filename,sep);\r\n for(Tokenizer::iterator beg=tok.begin(); beg!=tok.end(); ++beg) subStrs.push_back(*beg);\r\n filename = subStrs[subStrs.size()-1];\r\n for( unsigned int k=0; k < subStrs.size()-1; ++k )\r\n path = path +\"\\\\\"+ subStrs[k];\r\n path\t+= \"\\\\\";\r\n sep\t= char_separator(\".\");\r\n tok\t= Tokenizer(filename,sep);\r\n subStrs.clear();\r\n for(Tokenizer::iterator beg=tok.begin(); beg!=tok.end(); ++beg) subStrs.push_back(*beg);\r\n return subStrs[0];\r\n}\r\n\r\nvoid Mesh::cacheFaceNormals()\r\n{\r\n std::set faces = this->GetFaces();\r\n for(std::set::iterator fIter = faces.begin(); fIter!= faces.end(); fIter++)\r\n {\r\n float *temp = GetFaceNormal(*fIter);\r\n Vector3D *triadInput = new Vector3D(temp[0],temp[1],temp[2]);\r\n triadInput->normalize();\r\n fNormals_[*fIter] = triadInput;\r\n }\r\n}\r\n\r\nvoid Mesh::calculateVertexNormals()\r\n{\r\n for (std::set::iterator it = vertices_.begin(); it != vertices_.end(); ++it)\r\n {\r\n /* For each vertex find the averaged normal of the Faces */\r\n Vector3D *vertexNormal = new Vector3D(0.0f,0.0f,0.0f);\r\n Vertex *currVertex = (*it);\r\n std::vector currRotEdg = currVertex->GetRotation();\r\n unsigned int facesDone = currRotEdg.size();\r\n\r\n for(unsigned int iter=0; iterGetOtherEnd(currVertex)]);\r\n Vector3D vtmp(temp[0],temp[1],temp[2]);\r\n (*vertexNormal) += vtmp;\r\n }\r\n (*vertexNormal) /= facesDone;\r\n vertexNormal->normalize();\r\n vNormals_[currVertex] = vertexNormal;\r\n }\r\n}\r\n\r\nvoid Mesh::prepareTextureSets()\r\n{\r\n texture_Bcorner.push_back('a');\r\n texture_Bcorner.push_back('b');\r\n texture_Bcorner.push_back('c');\r\n texture_Bcorner.push_back('d');\r\n\r\n texture_Ycorner.push_back('e');\r\n texture_Ycorner.push_back('f');\r\n texture_Ycorner.push_back('g');\r\n texture_Ycorner.push_back('h');\r\n\r\n compat_Bcorner.push_back('a');\r\n compat_Bcorner.push_back('c');\r\n compat_Bcorner.push_back('f');\r\n compat_Bcorner.push_back('h');\r\n\r\n compat_Ycorner.push_back('b');\r\n compat_Ycorner.push_back('d');\r\n compat_Ycorner.push_back('e');\r\n compat_Ycorner.push_back('g');\r\n}\r\n\r\nvoid Mesh::createTileTexCoordList()\r\n{\r\n add2DCircularList(&_0aHead,'a',0.0,0.0);\r\n add2DCircularList(&_0aHead,'b',1.0,0.0);\r\n add2DCircularList(&_0aHead,'c',1.0,1.0);\r\n add2DCircularList(&_0aHead,'d',0.0,1.0);\r\n\r\n add2DCircularList(&_0bHead,'e',0.0,0.0);\r\n add2DCircularList(&_0bHead,'f',1.0,0.0);\r\n add2DCircularList(&_0bHead,'g',1.0,1.0);\r\n add2DCircularList(&_0bHead,'h',0.0,1.0);\r\n showDCircularList(_0aHead);\r\n showDCircularList(_0bHead);\r\n}\r\n\r\nbool Mesh::anyUnvisitedFaces(Face **retFacePntr,Tile **correspondingTile)\r\n{\r\n for (std::set::iterator fi = faces_.begin(); fi != faces_.end(); ++fi)\r\n {\r\n Tile *currTile = tile_map_[(*fi)];\r\n if( currTile->visited < 2 )\r\n {\r\n *retFacePntr = (*fi);\r\n *correspondingTile = currTile;\r\n return true;\r\n }\r\n }\r\n return false;\r\n}\r\n\r\nbool Mesh::LoadObjFile(const char *objFileName)\r\n{\r\n /* clear object */\r\n if ( !(vertices_.empty()) ) {\r\n Clear();\r\n }\r\n /* save file name */\r\n fileName_ = objFileName;\r\n\r\n /* ------------------ load .obj file ------------------ */\r\n FILE* inFile = fopen (objFileName, \"r\");\r\n if ( !inFile ) {\r\n ci::app::console() << \"Can not open file: \" << fileName_;\r\n }\r\n else {\r\n ci::app::console() << \"Model file: \" << fileName_;\r\n }\r\n /* 1st pass - read all the vertices */\r\n char buffer[512] = {0};\r\n float* coord;\r\n Vertex* newVertex;\r\n std::map id_vertex;\t/* vert ID starts from 1 */\r\n while ( fscanf( inFile, \"%s\", buffer) != EOF ) {\r\n if ( 'v' == buffer[0] ) {\r\n switch ( buffer[1] ) {\r\n case '\\0':\r\n coord = new float[3];\r\n if ( fscanf(inFile, \"%f %f %f\", &(coord[0]), &(coord[1]), &(coord[2])) != 3 ) {\r\n delete [] coord;\r\n std::cout << \"vertex \" << vertices_.size() << \" wrong\" << std::endl;\r\n return false;\r\n }\r\n else {\r\n newVertex = AddVertex();\r\n SetCoords(newVertex,coord);\r\n id_vertex[vertices_.size()] = newVertex;\r\n break;\r\n }\r\n\r\n case 'n':\r\n case 't':\r\n break;\r\n }\r\n }\r\n }\r\n ci::app::console() << \"Number of vertices: \" << vertices_.size() << std::endl;\r\n\r\n /* 2nd pass - add edges */\r\n numFacesObjFile_ = 0;\r\n int tempID, startID, endID;\r\n Edge* preEdge;\r\n Edge* newEdge;\r\n std::pair edgeIDpair;\t/* start <= end */\r\n std::pair firstPair;\t/* 1st edge pair */\r\n std::map, Edge*> vertex_id_edge;\t/* vert ID starts from 1 */\r\n std::map, Edge*>::iterator it_edge;\r\n rewind(inFile);\r\n /* process each face */\r\n while ( fscanf(inFile, \"%s\", buffer) != EOF) {\r\n if ( 'f' == buffer[0] && '\\0' == buffer[1] )\r\n {\r\n std::vector fVertices;\r\n while ( fscanf(inFile, \"%s\", buffer) != EOF )\r\n {\r\n if ( 1 == sscanf(buffer, \"%d\", &tempID) )\r\n {\r\n fVertices.push_back(tempID);\r\n }\r\n else\r\n {\t\t/* finish one face */\r\n numFacesObjFile_++;\r\n if ( fVertices.size() < 2 )\r\n {\r\n std::cout << \"Face only has \" << fVertices.size() << \" vertices\" << std::endl;\r\n return false;\r\n }\r\n /* 1st edge */\r\n startID = fVertices[0];\r\n endID = fVertices[1];\r\n if ( startID > endID ) {\r\n std::swap(startID, endID);\r\n }\r\n edgeIDpair.first = startID;\r\n edgeIDpair.second = endID;\r\n firstPair = edgeIDpair;\r\n it_edge = vertex_id_edge.find(edgeIDpair);\r\n if ( vertex_id_edge.end() == it_edge ) {\t/* edge not created */\r\n newEdge = ObjectStore::GetInstance()->CreateEdge(id_vertex[startID], id_vertex[endID]);\r\n edges_.insert(newEdge);\r\n vertex_id_edge[edgeIDpair] = newEdge;\r\n }\r\n else {\r\n newEdge = it_edge->second;\r\n }\r\n preEdge = newEdge;\r\n for (unsigned int i = 1; i < fVertices.size(); i++ )\r\n {\r\n startID = fVertices[i];\r\n endID = fVertices[(i+1 == fVertices.size() ? 0 : i+1)];\r\n if ( startID > endID ) {\r\n std::swap(startID, endID);\r\n }\r\n edgeIDpair.first = startID;\r\n edgeIDpair.second = endID;\r\n it_edge = vertex_id_edge.find(edgeIDpair);\r\n if ( vertex_id_edge.end() == it_edge) {\t\t// edge not created\r\n newEdge = ObjectStore::GetInstance()->CreateEdge(id_vertex[startID], id_vertex[endID]);\r\n edges_.insert(newEdge);\r\n vertex_id_edge[edgeIDpair] = newEdge;\r\n }\r\n else {\r\n newEdge = it_edge->second;\r\n }\r\n /* add to rotation */\r\n id_vertex[fVertices[i]]->InsertEdgeInRotation_load(newEdge, preEdge);\r\n preEdge = newEdge;\r\n }\r\n // last & 1st edges in rotation\r\n newEdge = vertex_id_edge[firstPair];\r\n id_vertex[fVertices[0]]->InsertEdgeInRotation_load(newEdge, preEdge);\r\n\r\n fVertices.clear();\t// start a new face\r\n\r\n if ( 'f' != buffer[0] )\r\n {\r\n break;\r\n }\r\n }\r\n }\r\n }\r\n }\r\n fclose(inFile);\r\n ci::app::console() << \"Number of edges: \" << edges_.size() << std::endl;\r\n ci::app::console() << \"Number of faces: \" << numFacesObjFile_ << std::endl;\r\n ReComputeFaces();\r\n calculateVertexNormals();\r\n cacheFaceNormals();\r\n\r\n pumpMesh();\r\n ci::app::console() << \"Face extrusion completed.\" << std::endl;\r\n traverseFaces_PLUSES();\r\n //traverseFaces_TWISTS();\r\n ci::app::console() << \"Tile traversal completed.\" << std::endl;\r\n if(baseCrvType==CATMULLROMSPLINE) generateCtrlPnts4InterpolationSpline();\r\n generateWngTubes();\r\n return true;\r\n}\r\n\r\nbool Mesh::Clear()\r\n{\r\n for (std::set::iterator it = vertices_.begin();\r\n it != vertices_.end(); ++it) {\r\n (*it)->ClearRotations();\r\n ObjectStore::GetInstance()->DeleteVertex(*it);\r\n }\r\n vertices_.clear();\r\n\r\n for (std::set::iterator it = edges_.begin();\r\n it != edges_.end(); ++it) {\r\n ObjectStore::GetInstance()->DeleteEdge(*it);\r\n }\r\n edges_.clear();\r\n\r\n for (std::set::iterator it = faces_.begin();\r\n it != faces_.end(); ++it) {\r\n ObjectStore::GetInstance()->DeleteFace(*it);\r\n }\r\n faces_.clear();\r\n face_map_.clear();\r\n fNormals_.clear();\r\n vNormals_.clear();\r\n tile_map_.clear();\r\n wngCrvs.clear();\r\n mWvngTubes.clear();\r\n numFacesObjFile_ = 0;\r\n vertex_treeIDMap_.clear();\r\n treeID_VertexSetMap_.clear();\r\n return true;\r\n}\r\n\r\nvoid Mesh::drawMesh(bool wireframe, bool lighting, bool drawBaseMesh, bool paintedMesh, bool tiledMesh, bool drawWeaving,\r\n GLint TURN1_OR_TOUCH, GLint TURN2_OR_CROSS, GLint DOUBLE_CROSS)\r\n{\r\n if(paintedMesh)\r\n {\r\n glPushMatrix();\r\n for( std::set::iterator fi = faces_.begin(); fi != faces_.end(); ++fi )\r\n {\r\n Tile* currT = tile_map_[*fi];\r\n // float *normal = GetFaceNormal(*fi);\r\n if( currT->tex == OA ) {\r\n glBindTexture(GL_TEXTURE_2D, TURN1_OR_TOUCH);\r\n }\r\n else if( currT->tex == OB ) {\r\n glBindTexture(GL_TEXTURE_2D, TURN2_OR_CROSS);\r\n }\r\n\r\n glBegin(GL_QUADS);\r\n // glNormal3fv(normal);\r\n for( vector::iterator vIt = currT->actVerts.begin(); vIt != currT->actVerts.end(); ++vIt )\r\n {\r\n Vector3D *vnormal = vNormals_[*vIt];\r\n float *currVertex = coords_[*vIt];\r\n DCircularList *uvmap = currT->texCoords[*vIt];\r\n glNormal3f(vnormal->DX(), vnormal->DY(), vnormal->DZ());\r\n glTexCoord2f( uvmap->u, uvmap->v );\r\n glVertex3fv( currVertex );\r\n }\r\n glEnd();\r\n glBindTexture(GL_TEXTURE_2D, NULL);\r\n }\r\n glPopMatrix();\r\n }\r\n\r\n if(drawBaseMesh) {\r\n glPushMatrix();\r\n if(lighting) glEnable(GL_COLOR_MATERIAL);\r\n glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);\r\n glColor4f(0.5f, 0.5f, 0.5f, 1.0f);\r\n for( std::set::iterator fi = faces_.begin(); fi != faces_.end(); ++fi )\r\n {\r\n std::vector cFVertices = (*fi)->GetVertices();\r\n glColor4f(1.0,1.0,1.0,1.0);\r\n glBegin(GL_POLYGON);\r\n glNormal3fv( GetFaceNormal(*fi) );\r\n for(unsigned int i=0;i::iterator fi = faces_.begin(); fi != faces_.end(); ++fi )\r\n {\r\n Vector3D *vtmp;\r\n Tile* currT = tile_map_[*fi];\r\n glBegin(GL_QUADS);\r\n float *normal = GetFaceNormal(*fi);\r\n glColor4f(1.0f, 0.0f, 0.0f, 1.0f);\t// RED\r\n glNormal3fv(normal);\r\n for( Vec3DPtrIter it = currT->up.begin(); it != currT->up.end(); it++ )\r\n {\r\n vtmp = *it;\r\n glVertex3f( vtmp->DX(), vtmp->DY(), vtmp->DZ() );\r\n }\r\n\r\n glColor4f(0.0f, 1.0f, 0.0f, 1.0f);\t// GREEN\r\n glNormal3f(-normal[0],-normal[1],-normal[2]);\r\n for( Vec3DPtrIter it = currT->down.begin(); it != currT->down.end(); it++ )\r\n {\r\n vtmp = *it;\r\n glVertex3f( vtmp->DX(), vtmp->DY(), vtmp->DZ() );\r\n }\r\n glEnd();\r\n\r\n glPointSize(4.0f);\r\n glBegin(GL_POINTS);\r\n vtmp = currT->curve1[1];\r\n glColor4f(1.0f, 0.0f, 0.0f, 1.0f);\t// RED\r\n glVertex3f( vtmp->DX(), vtmp->DY(), vtmp->DZ() );\r\n vtmp = currT->curve2[1];\r\n glColor4f(0.0f, 1.0f, 0.0f, 1.0f);\t// GREEN\r\n glVertex3f( vtmp->DX(), vtmp->DY(), vtmp->DZ() );\r\n glEnd();\r\n glPointSize(1.0f);\r\n }\r\n glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);\r\n if(lighting) glDisable(GL_COLOR_MATERIAL);\r\n glEnable(GL_CULL_FACE);\r\n glPopMatrix();\r\n }\r\n\r\n if(drawWeaving)\r\n {\r\n glPushMatrix();\r\n GLfloat mat_amb[] = {0.05,0.05,0.05,1.0};\r\n GLfloat mat_diff[4];\r\n GLfloat mat_spec[] = {1.0,1.0,1.0,1.0};\r\n GLfloat mat_shininess[] = {100.0};\r\n float r = 0.3f;\r\n float g = 0.3f;\r\n float b = 0.3f;\r\n for (std::vector::iterator tube = mWvngTubes.begin(); tube != mWvngTubes.end(); ++tube)\r\n {\r\n WvngTube* currTube = *tube;\r\n if( r < 1.0f )\r\n r += 0.2f;\r\n else if( g < 1.0f )\r\n g += 0.2f;\r\n else if( b < 1.0f )\r\n b += 0.2f;\r\n else {\r\n r = 0.3f;\r\n g = 0.3f;\r\n b = 0.3f;\r\n }\r\n mat_diff[0] = r; mat_diff[1] = g; mat_diff[2] = b; mat_diff[3] = 1.0;\r\n glPushMatrix();\r\n glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,mat_amb);\r\n glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,mat_diff);\r\n glMaterialfv(GL_FRONT,GL_SPECULAR,mat_spec);\r\n glMaterialfv(GL_FRONT,GL_SHININESS,mat_shininess);\r\n\r\n gluBeginSurface(theNurb);\r\n gluNurbsSurface(theNurb, currTube->uKnotCount, currTube->uKnots,\r\n currTube->vKnotCount, currTube->vKnots,\r\n currTube->uStride, currTube->vStride, currTube->ctlPoints,\r\n currTube->uOrder, currTube->vOrder, GL_MAP2_VERTEX_3);\r\n gluEndSurface(theNurb);\r\n glPopMatrix();\r\n }\r\n /*glEnable(GL_COLOR_MATERIAL);\r\n glColor4f(1.0,1.0,1.0,1.0f);\r\n glPointSize(4.0);\r\n glBegin(GL_POINTS);\r\n for(vector::iterator it = wngCrvs.begin(); it != wngCrvs.end(); ++it )\r\n {\r\n for(Vec3DPtrIter v = (*it).myPnts.begin(); v != (*it).myPnts.end(); ++v )\r\n {\r\n Vector3D tmp = *(*v);\r\n glVertex3f(tmp.DX(),tmp.DY(),tmp.DZ());\r\n }\r\n break;\r\n }\r\n glEnd();\r\n glPointSize(1.0);\r\n glDisable(GL_COLOR_MATERIAL);\r\n */\r\n glPopMatrix();\r\n }\r\n}\r\n\r\nvoid Mesh::pumpMesh()\r\n{\r\n /* Now move around faces and generate the positions */\r\n for (std::set::iterator it = faces_.begin(); it != faces_.end(); ++it)\r\n {\r\n std::vector faceVertices = (*it)->GetVertices();\r\n Tile *myTile = new Tile(faceVertices.size());\r\n\r\n for(unsigned int i=0; iaddUpAndDown(faceVertices[i],up,down);\r\n }\r\n myTile->generateCurvePoints();\r\n tile_map_[(*it)] = myTile;\r\n }\r\n}\r\n\r\nvoid Mesh::resetTexturePaintMarkers()\r\n{\r\n set faces = this->GetFaces();\r\n for(set::iterator fIter = faces.begin(); fIter!= faces.end(); ++fIter) {\r\n tile_map_[*fIter]->marked\t= -1;\r\n tile_map_[*fIter]->tex\t\t= OA;\r\n tile_map_[*fIter]->texCoords.clear();\r\n }\r\n this->vertex_treeIDMap_.clear();\r\n this->treeID_VertexSetMap_.clear();\r\n}\r\n\r\nvoid Mesh::paintTexturesOnMesh()\r\n{\r\n for( std::set::iterator vi = vertices_.begin(); vi != vertices_.end(); ++vi )\r\n {\r\n char myColor\t\t\t='0';\r\n std::vector edges= (*vi)->GetRotation();\r\n Vertex *end1\t\t\t= *vi;\r\n Face *prevF\t\t\t\t= 0;\r\n for(vector::iterator eIter = edges.begin(); eIter != edges.end(); ++eIter)\r\n {\r\n Vertex *end2= (*eIter)->GetOtherEnd(end1);\r\n Face* f\t\t= face_map_[end1][end2];\r\n if( tile_map_[f]->marked != -1 ) {\r\n Tile* t\t\t= tile_map_[f];\r\n char mark\t= t->texCoords[end2]->name;\r\n vector::iterator idx = find(texture_Bcorner.begin(), texture_Bcorner.end(), mark);\r\n myColor = texture_Bcorner.at(((idx-texture_Bcorner.begin())+1)%FACE_NUM_V);\r\n break;\r\n }\r\n prevF = f;\r\n }\r\n\r\n prevF = 0;\r\n if( myColor=='0' ) myColor = (*texture_Bcorner.begin());\r\n for( vector::iterator eIter = edges.begin(); eIter != edges.end(); ++eIter )\r\n {\r\n Vertex *end2= (*eIter)->GetOtherEnd(end1);\r\n Face* f\t\t= face_map_[end1][end2];\r\n if( tile_map_[f]->marked == -1 )\r\n {\r\n Tile* t = tile_map_[f];\r\n vector::iterator clrIndex = find(texture_Bcorner.begin(),texture_Bcorner.end(),myColor);\r\n int myClrPos\t\t\t\t\t= clrIndex - texture_Bcorner.begin();\r\n\r\n int idx1,idx2;\r\n for(vector::iterator tV = t->actVerts.begin(); tV != t->actVerts.end(); ++tV )\r\n {\r\n if(end1 == *tV)\r\n idx1 = tV - t->actVerts.begin();\r\n else if(end2 == *tV)\r\n idx2 = tV - t->actVerts.begin();\r\n }\r\n\r\n DCircularList *vTexPntr = rotateDCircularListFrwd(_0aHead,myClrPos);\r\n DCircularList *iter\t\t= vTexPntr;\r\n if(idx1 < idx2)\r\n {\r\n do {\r\n t->texCoords[t->actVerts[idx1]]\t= iter;\r\n iter = iter->next;\r\n if( !(++idx1 < 4) ) idx1 = 0;\r\n }while(iter!=vTexPntr);\r\n } else {\r\n do {\r\n t->texCoords[t->actVerts[idx1]]\t= iter;\r\n iter = iter->prev;\r\n if( !(--idx1 >= 0) ) idx1 = 3;\r\n }while(iter!=vTexPntr);\r\n }\r\n t->marked\t= t->marked + 1;\r\n t->tex\t\t= OA;\r\n }\r\n prevF = f;\r\n }\r\n }\r\n}\r\n\r\nbool Mesh::findUnConnectedFace(Face **returnValue, Vertex **returnVertex)\r\n{\r\n set faces = this->GetFaces();\r\n for(set::iterator fIter = faces.begin(); fIter != faces.end(); ++fIter)\r\n {\r\n if(tile_map_[*fIter]->marked==0 && tile_map_[*fIter]->tex==OA) {\r\n *returnValue = *fIter;\r\n vector myVertices = (*returnValue)->GetVertices();\r\n Tile *currT = tile_map_[(*returnValue)];\r\n for( vector::iterator vit = myVertices.begin(); vit != myVertices.end(); ++vit) {\r\n if( currT->texCoords[*vit]->name == 'b' || currT->texCoords[*vit]->name == 'd' ) {\r\n *returnVertex = *vit;\r\n break;\r\n }\r\n }\r\n return true;\r\n }\r\n }\r\n *returnValue = 0;\r\n return false;\r\n}\r\n\r\nvoid Mesh::incMarkerOnFacesIncident(Vertex *v)\r\n{\r\n vector rot\t= v->GetRotation();\r\n for(vector::iterator eIt = rot.begin(); eIt != rot.end(); ++eIt)\r\n {\r\n Tile *t = tile_map_[ face_map_[v][(*eIt)->GetOtherEnd(v)] ];\r\n t->marked = t->marked + 1;\r\n }\r\n}\r\n\r\nVertex* Mesh::getNextPivotInFace(Face *f, Vertex *v, char &colorName, int &index1, int &index2)\r\n{\r\n Tile *t = tile_map_[f];\r\n vector matchBInOB(2);\r\n vector::iterator newColorEnd = set_intersection(compat_Ycorner.begin(),compat_Ycorner.end(), texture_Bcorner.begin(), texture_Bcorner.end(), matchBInOB.begin());\r\n colorName = (*matchBInOB.begin());\r\n vector::iterator index = find(t->actVerts.begin(), t->actVerts.end(),v);\r\n if(index != t->actVerts.end()) {\r\n index1 = index - t->actVerts.begin();\r\n index2 = (index1+1)%FACE_NUM_V;\r\n return t->actVerts.at( ( ( index1+2 )%FACE_NUM_V ) );\r\n } else {\r\n app::console()<<\"Vertex not found, something fishy!\"<GetFaces().begin());\r\n currT\t\t= tile_map_[currFace];\r\n vector myVertices = currFace->GetVertices();\r\n for( vector::iterator vit = myVertices.begin(); vit != myVertices.end(); ++vit) {\r\n if( currT->texCoords[*vit]->name == 'b' || currT->texCoords[*vit]->name == 'd' ) {\r\n prevPivot = *vit;\r\n break;\r\n }\r\n }\r\n firstRun\t= false;\r\n }\r\n\r\n if( currFace!=prevFace && currFace!=0 && prevPivot!= 0 )\r\n {\r\n char colorName;\r\n int idx1,idx2;\r\n currT\t\t\t\t= tile_map_[currFace];\r\n incMarkerOnFacesIncident(prevPivot);\r\n idx1\t\t\t\t= idx2 = -1;\r\n pivot\t\t\t\t= getNextPivotInFace(currFace,prevPivot,colorName,idx1,idx2);\r\n\r\n if(! ( idx1>=0 && idx1<4 & idx2>=0 && idx2<4 ) ) app::console()<<\"idx1,idx2 \"<::iterator findOut\t= find(texture_Ycorner.begin(), texture_Ycorner.end(),colorName);\r\n DCircularList *vTexPntr\t\t\t= rotateDCircularListFrwd(_0bHead, findOut-texture_Ycorner.begin());\r\n DCircularList *iter\t\t\t\t= vTexPntr;\r\n if(idx1 < idx2) {\r\n do {\r\n currT->texCoords[currT->actVerts[idx1]]\t= iter;\r\n iter = iter->next;\r\n if( !(++idx1 < 4) ) idx1 = 0;\r\n }while(iter!=vTexPntr);\r\n } else {\r\n do {\r\n currT->texCoords[currT->actVerts[idx1]]\t= iter;\r\n iter = iter->prev;\r\n if( !(--idx1 >= 0) ) idx1 = 3;\r\n }while(iter!=vTexPntr);\r\n }\r\n currT->tex\t\t= OB;\r\n vertex_treeIDMap_[prevPivot] = curveID;\r\n vertex_treeIDMap_[pivot] = curveID;\r\n treeID_VertexSetMap_[curveID].insert(prevPivot);\r\n treeID_VertexSetMap_[curveID].insert(pivot);\r\n prevPivot\t\t= pivot;\r\n prevFace\t\t= currFace;\r\n\r\n vector rot\t= pivot->GetRotation();\r\n for(vector::iterator eIt = rot.begin(); eIt != rot.end(); ++eIt)\r\n {\r\n Face *temp = face_map_[pivot][(*eIt)->GetOtherEnd(pivot)];\r\n Tile *t = tile_map_[temp];\r\n if( t->marked == 0 && t->tex == OA && prevFace!=temp ) {\r\n currFace = temp;\r\n break;\r\n }\r\n }\r\n }else{\r\n app::console()<<\"No next face assigned => Either all connected or we have disconnected trees.\"< 1 )\r\n {\r\n vector matchBInOB(2);\r\n vector::iterator newColorEnd = set_intersection(compat_Ycorner.begin(),compat_Ycorner.end(), texture_Bcorner.begin(), texture_Bcorner.end(), matchBInOB.begin());\r\n vector::iterator findOut\t= find(texture_Ycorner.begin(), texture_Ycorner.end(),(*matchBInOB.begin()));\r\n DCircularList *vTexPntr\t\t\t= rotateDCircularListFrwd(_0bHead, findOut-texture_Ycorner.begin());\r\n DCircularList *iter\t\t\t\t= vTexPntr;\r\n\r\n set faces = this->GetFaces();\r\n for(set::iterator fIter = faces.begin(); fIter != faces.end(); ++fIter)\r\n {\r\n Tile *t\t\t= tile_map_[*fIter];\r\n if( t->tex == OA && t->marked >= 2 )\r\n {\r\n Vertex *jumpIn = 0;\r\n vector myVertices = (*fIter)->GetVertices();\r\n for( vector::iterator vit = myVertices.begin(); vit != myVertices.end(); ++vit) {\r\n if( t->texCoords[*vit]->name == 'b' || t->texCoords[*vit]->name == 'd' ) {\r\n jumpIn = *vit;\r\n break;\r\n }\r\n }\r\n vector::iterator index = find(t->actVerts.begin(), t->actVerts.end(),jumpIn);\r\n int idx1 = index - t->actVerts.begin();\r\n int idx2 = (idx1+2)%FACE_NUM_V;\r\n Vertex *jumpOtherEnd = t->actVerts.at(idx2);\r\n int v1CrvId = vertex_treeIDMap_[jumpIn];\r\n int v2CrvId = vertex_treeIDMap_[jumpOtherEnd];\r\n if( v1CrvId != v2CrvId )\r\n {\r\n set c2Vertices = treeID_VertexSetMap_[v2CrvId];\r\n for(set::iterator it = c2Vertices.begin(); it != c2Vertices.end(); ++it ) {\r\n treeID_VertexSetMap_[v1CrvId].insert(*it);\r\n vertex_treeIDMap_[*it] = v1CrvId;\r\n }\r\n map>::iterator eraseCrv = treeID_VertexSetMap_.find(v2CrvId);\r\n treeID_VertexSetMap_.erase(eraseCrv);\r\n // Now assign tex coords according to new Tile OB for this face using idx1 & idx2\r\n if(idx1 < idx2) {\r\n do {\r\n t->texCoords[t->actVerts[idx1]]\t= iter;\r\n iter = iter->next;\r\n if( !(++idx1 < 4) ) idx1 = 0;\r\n }while(iter!=vTexPntr);\r\n } else {\r\n do {\r\n t->texCoords[t->actVerts[idx1]]\t= iter;\r\n iter = iter->prev;\r\n if( !(--idx1 >= 0) ) idx1 = 3;\r\n }while(iter!=vTexPntr);\r\n }\r\n t->tex\t\t= OB;\r\n } else {\r\n app::console()<<\"Phase 2: OA Tile with same curve corners\"< matchBInOB(2);\r\n vector::iterator newColorEnd = set_intersection(compat_Ycorner.begin(),compat_Ycorner.end(), texture_Bcorner.begin(), texture_Bcorner.end(), matchBInOB.begin());\r\n vector::iterator findOut\t= find(texture_Ycorner.begin(), texture_Ycorner.end(),(*matchBInOB.begin()));\r\n DCircularList *vTexPntr\t\t\t= rotateDCircularListFrwd(_0bHead, findOut-texture_Ycorner.begin());\r\n DCircularList *iter\t\t\t\t= vTexPntr;\r\n\r\n set faces = this->GetFaces();\r\n for(set::iterator fIter = faces.begin(); fIter != faces.end(); ++fIter)\r\n {\r\n Tile *t\t\t= tile_map_[*fIter];\r\n if( t->tex == OA && t->marked == 1 ) {\r\n // Faces incident on isolated vertices will be still with markers set to 1\r\n Vertex *jumpIn = 0;\r\n vector myVertices = (*fIter)->GetVertices();\r\n for( vector::iterator vit = myVertices.begin(); vit != myVertices.end(); ++vit) {\r\n if( t->texCoords[*vit]->name == 'b' || t->texCoords[*vit]->name == 'd' ) {\r\n jumpIn = *vit;\r\n break;\r\n }\r\n }\r\n vector::iterator index = find(t->actVerts.begin(), t->actVerts.end(),jumpIn);\r\n int idx1 = index - t->actVerts.begin();\r\n int idx2 = (idx1+2)%FACE_NUM_V;\r\n Vertex *jumpOtherEnd = t->actVerts.at(idx2);\r\n map::iterator treeId = vertex_treeIDMap_.find(jumpIn);\r\n int v1CrvId = ( treeId != vertex_treeIDMap_.end() ? treeId->second : -1 );\r\n treeId = vertex_treeIDMap_.find(jumpOtherEnd);\r\n int v2CrvId = ( treeId != vertex_treeIDMap_.end() ? treeId->second : -1 );\r\n if( (v1CrvId!=-1 && v2CrvId==-1) || (v2CrvId!=-1 && v1CrvId==-1) ) {\r\n if(v1CrvId!=-1 && v2CrvId==-1) {\r\n vertex_treeIDMap_[jumpOtherEnd] = v1CrvId;\r\n treeID_VertexSetMap_[v1CrvId].insert(jumpOtherEnd);\r\n incMarkerOnFacesIncident(jumpOtherEnd);\r\n } else {\r\n vertex_treeIDMap_[jumpIn] = v2CrvId;\r\n treeID_VertexSetMap_[v2CrvId].insert(jumpIn);\r\n incMarkerOnFacesIncident(jumpIn);\r\n }\r\n // Now assign tex coords according to new Tile OB for this face using idx1 & idx2\r\n if(idx1 < idx2) {\r\n do {\r\n t->texCoords[t->actVerts[idx1]]\t= iter;\r\n iter = iter->next;\r\n if( !(++idx1 < 4) ) idx1 = 0;\r\n }while(iter!=vTexPntr);\r\n } else {\r\n do {\r\n t->texCoords[t->actVerts[idx1]]\t= iter;\r\n iter = iter->prev;\r\n if( !(--idx1 >= 0) ) idx1 = 3;\r\n }while(iter!=vTexPntr);\r\n }\r\n t->tex\t\t= OB;\r\n }\r\n }\r\n }\r\n } else\r\n app::console()<<\"No isolated vertices, hence phase 3 complete.\"< extns; extns.push_back(\"*.obj,*.OBJ\");\r\n getOriginalFileName(fileName_,path);\r\n fs::path newObjFilePath = app::getSaveFilePath(path,extns);\r\n if( !newObjFilePath.empty() ) {\r\n string mtlpath;\r\n string mtlfilename = getOriginalFileName(newObjFilePath.string(),mtlpath) + \".mtl\";\r\n mtlpath += mtlfilename;\r\n string bcornerMtl = \"BlueCorner\";\r\n string ycornerMtl = \"YellowCorner\";\r\n\r\n //create index for vertices, normals and texture coordinates\r\n map v2IndexMap;\r\n map vNormalIndexMap;\r\n map texOAIndexMap, texOBIndexMap;\r\n int vIndex=1;\r\n for(set::iterator vit = vertices_.begin(); vit != vertices_.end(); ++vit)\r\n v2IndexMap[*vit] = vIndex++;\r\n int vNormalIndex = 1;\r\n for(map::iterator vnit = vNormals_.begin(); vnit != vNormals_.end(); ++vnit)\r\n vNormalIndexMap[vnit->first] = vNormalIndex++;\r\n DCircularList *itOA = _0aHead->prev;\r\n int texOAIndex = 1;\r\n DCircularList *itOB = _0bHead->prev;\r\n int texOBIndex = 1;\r\n for(int k=0; k<4; ++k) {\r\n texOAIndexMap[itOA] = texOAIndex++; texOBIndexMap[itOB] = texOBIndex++;\r\n itOA = itOA->prev; itOB = itOB->prev;\r\n }\r\n\r\n //Now write the OBJ file and material files\r\n FILE *objHandle = fopen(newObjFilePath.string().c_str(),\"w\");\r\n fprintf(objHandle,\"%s\",\"# File format : Wavefront OBJ file \\n\");\r\n fprintf(objHandle,\"%s\",\"# Author : Pradeep Garigipati\\n\");\r\n fprintf(objHandle,\"%s\",\"# Date : 03/05/2010\\n\");\r\n fprintf(objHandle,\"%s\",\"# -----------------------------------\\n\\n\");\r\n\r\n fprintf(objHandle,\"%s\",\"# Using the below material file \\n\");\r\n fprintf(objHandle,\"mtllib %s\\n\\n\",mtlfilename.c_str());\r\n\r\n fprintf(objHandle,\"# Vertices set size = %d\\n\",v2IndexMap.size());\r\n for(map::iterator v = v2IndexMap.begin(); v!= v2IndexMap.end(); ++v){\r\n float *coords = coords_[v->first];\r\n //app::console()<<\"v \"<::iterator vn = vNormalIndexMap.begin(); vn!= vNormalIndexMap.end(); ++vn){\r\n Vector3D *normal = vNormals_[vn->first];\r\n //app::console()<<\"v \"<DX()<<\" \"<DY()<<\" \"<DZ()];\r\n fprintf(objHandle,\"vn %f %f %f\\n\",normal->DX(),normal->DY(),normal->DZ());\r\n }\r\n fprintf(objHandle,\"%s\",\"\\n\\n\");\r\n\r\n fprintf(objHandle,\"# Texture coordinates set size = %d\\n\",texOAIndexMap.size());\r\n for(map::iterator texCrd = texOAIndexMap.begin(); texCrd!= texOAIndexMap.end(); ++texCrd){\r\n DCircularList *textureCoord = texCrd->first;\r\n fprintf(objHandle,\"vt %f %f\\n\",textureCoord->u,textureCoord->v);\r\n }\r\n fprintf(objHandle,\"%s\",\"\\n\\n\");\r\n\r\n fprintf(objHandle,\"# Faces set size = %d\\n\",faces_.size());\r\n fprintf(objHandle,\"usemtl %s\\n\", bcornerMtl.c_str() );\r\n for(set::iterator f = faces_.begin(); f != faces_.end(); ++f) {\r\n Tile *t = tile_map_[*f];\r\n if(t->tex == OA) {\r\n string out=\"f \";\r\n vector verts = (*f)->GetVertices();\r\n for(vector::iterator vit = verts.begin(); vit != verts.end(); ++vit) {\r\n stringstream ss;\r\n string hold;\r\n ss<texCoords[*vit]]<<\"/\"<>hold;\r\n out = out + \" \" + hold;\r\n }\r\n fprintf(objHandle,\"%s\\n\",out.c_str());\r\n }\r\n }\r\n fprintf(objHandle,\"usemtl %s\\n\", ycornerMtl.c_str() );\r\n for(set::iterator f = faces_.begin(); f != faces_.end(); ++f) {\r\n Tile *t = tile_map_[*f];\r\n if(t->tex == OB) {\r\n string out=\"f \";\r\n vector verts = (*f)->GetVertices();\r\n for(vector::iterator vit = verts.begin(); vit != verts.end(); ++vit) {\r\n stringstream ss;\r\n string hold;\r\n ss<texCoords[*vit]]<<\"/\"<>hold;\r\n out = out + \" \" + hold;\r\n }\r\n fprintf(objHandle,\"%s\\n\",out.c_str());\r\n }\r\n }\r\n fprintf(objHandle,\"%s\",\"\\n\");\r\n fclose(objHandle);\r\n\r\n FILE *mtlHandle = fopen(mtlfilename.c_str(),\"w\");\r\n fprintf(mtlHandle,\"%s\",\"# File format : Material MTL file \\n\");\r\n fprintf(mtlHandle,\"%s\",\"# Author : Pradeep Garigipati\\n\");\r\n fprintf(mtlHandle,\"%s\",\"# Date : 03/05/2010\\n\\n\");\r\n\r\n fprintf(mtlHandle,\"newmtl %s\\n\",bcornerMtl.c_str());\r\n fprintf(mtlHandle,\"Ka %f %f %f\\n\", 1.0, 1.0, 1.0);\r\n fprintf(mtlHandle,\"Kd %f %f %f\\n\", 1.0, 1.0, 1.0);\r\n fprintf(mtlHandle,\"Ks %f %f %f\\n\", 0.0, 0.0, 0.0);\r\n fprintf(mtlHandle,\"d %f\\n\", 1.0);\r\n fprintf(mtlHandle,\"illum %d\\n\", 2);\r\n fprintf(mtlHandle,\"map_Ka -clamp on %s\\n\", \"0a.png\");\r\n fprintf(mtlHandle,\"map_Kd -clamp on %s\\n\", \"0a.png\");\r\n fprintf(mtlHandle,\"map_Ks -clamp on %s\\n\", \"0a.png\");\r\n\r\n fprintf(mtlHandle,\"newmtl %s\\n\", ycornerMtl.c_str());\r\n fprintf(mtlHandle,\"Ka %f %f %f\\n\", 1.0, 1.0, 1.0);\r\n fprintf(mtlHandle,\"Kd %f %f %f\\n\", 1.0, 1.0, 1.0);\r\n fprintf(mtlHandle,\"Ks %f %f %f\\n\", 0.0, 0.0, 0.0);\r\n fprintf(mtlHandle,\"d %f\\n\", 1.0);\r\n fprintf(mtlHandle,\"illum %d\\n\", 2);\r\n fprintf(mtlHandle,\"map_Ka -clamp on %s\\n\", \"0b.png\");\r\n fprintf(mtlHandle,\"map_Kd -clamp on %s\\n\", \"0b.png\");\r\n fprintf(mtlHandle,\"map_Ks -clamp on %s\\n\", \"0b.png\");\r\n fclose(mtlHandle);\r\n }\r\n}\r\n\r\nvoid Mesh::traverseFaces_PLUSES()\r\n{\r\n Face* currFace = 0;\r\n Tile* currTile = 0;\r\n\r\n while(anyUnvisitedFaces(&currFace,&currTile))\r\n {\r\n bool currCurve = true;\r\n Edge* prevDirectionEdge = 0;\r\n KNOT prevFaceKnotType = NOTHING;\r\n Face* prevFace = 0;\r\n Tile* prevTile = 0;\r\n Edge* directionEdge = 0;\r\n wngCrvCtrlPnts currCrv;\r\n\r\n while(currCurve)\r\n {\r\n if(currTile->visited == 0)\r\n {\r\n Edge *edg = 0;\r\n bool isCurve1,isReverse;\r\n Vertex *start = 0;\r\n Vertex *end = 0;\r\n // Pick the entry/random-entry edge and start,end vertices of the corresponding face\r\n if(directionEdge==0)\r\n edg = (*(currFace->GetEdges().begin()));\r\n else\r\n edg = directionEdge;\r\n start = edg->GetStart();\r\n end = edg->GetEnd();\r\n if( face_map_[start][end] != currFace ) {\r\n Vertex* temp= start;\r\n start = end;\r\n end = temp;\r\n }\r\n // Alternate the Tile patterns OR generate TWIST points in even-face cycle\r\n if(prevFaceKnotType == currTile->knotType && (prevFaceKnotType == PLUS1 || prevFaceKnotType == PLUS2)) {\r\n currTile->swapCurveMidPoints();\r\n currTile->knotType = ( prevFaceKnotType == PLUS1 ? PLUS2 : PLUS1 );\r\n }else if(currTile->knotType == TWIST1)\r\n currTile->generateTwist1Points();\r\n else if(currTile->knotType == TWIST2)\r\n currTile->generateTwist2Points();\r\n // find the curve of entry based on the entry edge\r\n currTile->findCurveAndDirection(start,end,isCurve1,isReverse);\r\n // Push the corresponding curve points\r\n if(isCurve1) {\r\n if(isReverse) {\r\n /*for( std::vector::reverse_iterator iter = currTile->curve1.rbegin(); iter != currTile->curve1.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);*/\r\n for( int crv=currTile->curve1.size()-2; crv>0; crv--)\r\n currCrv.myPnts.push_back(currTile->curve1[crv]);\r\n currTile->isUsedCrv1Rev = YES;\r\n Vector3D *derv = new Vector3D((*(*currTile->curve1.begin()))-(*(*currTile->curve1.rbegin())));\r\n derv->normalize();\r\n currCrv.derivatives.push_back(derv);\r\n } else {\r\n /*for( std::vector::iterator iter = currTile->curve1.begin(); iter != currTile->curve1.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);*/\r\n for( int crv=1; crvcurve1.size()-1; crv++)\r\n currCrv.myPnts.push_back(currTile->curve1[crv]);\r\n currTile->isUsedCrv1Rev = NO;\r\n Vector3D *derv = new Vector3D((*(*currTile->curve1.rbegin()))-(*(*currTile->curve1.begin())));\r\n derv->normalize();\r\n currCrv.derivatives.push_back(derv);\r\n }\r\n currTile->isCrv1Used = YES;\r\n } else {\r\n if(isReverse) {\r\n /*for( std::vector::reverse_iterator iter = currTile->curve2.rbegin(); iter != currTile->curve2.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);*/\r\n for( int crv=currTile->curve2.size()-2; crv>0; crv--)\r\n currCrv.myPnts.push_back(currTile->curve2[crv]);\r\n currTile->isUsedCrv2Rev = YES;\r\n Vector3D *derv = new Vector3D((*(*currTile->curve2.begin()))-(*(*currTile->curve2.rbegin())));\r\n derv->normalize();\r\n currCrv.derivatives.push_back(derv);\r\n } else {\r\n /*for( std::vector::iterator iter = currTile->curve2.begin(); iter != currTile->curve2.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);*/\r\n for( int crv=1; crvcurve2.size()-1; crv++)\r\n currCrv.myPnts.push_back(currTile->curve2[crv]);\r\n currTile->isUsedCrv2Rev = NO;\r\n Vector3D *derv = new Vector3D((*(*currTile->curve2.rbegin()))-(*(*currTile->curve2.begin())));\r\n derv->normalize();\r\n currCrv.derivatives.push_back(derv);\r\n }\r\n currTile->isCrv2Used = YES;\r\n }\r\n // store face normal to help generate thread\r\n currCrv.triadNorms.push_back(fNormals_[currFace]);\r\n currTile->visited++;\r\n // extract the direction edge based on curve used\r\n if(currTile->knotType == TWIST1) {\r\n if(isCurve1)\r\n directionEdge = (isReverse==true ? end->GetNextEdgeInRotation(edg) : start->GetPreviousEdgeInRotation(edg));\r\n else\r\n directionEdge = (isReverse==true ? start->GetPreviousEdgeInRotation(edg) : end->GetNextEdgeInRotation(edg));\r\n } else if(currTile->knotType == TWIST2) {\r\n if(isCurve1)\r\n directionEdge = (isReverse==true ? start->GetPreviousEdgeInRotation(edg) : end->GetNextEdgeInRotation(edg));\r\n else\r\n directionEdge = (isReverse==true ? end->GetNextEdgeInRotation(edg) : start->GetPreviousEdgeInRotation(edg));\r\n } else {\r\n Edge* adjEdge = end->GetNextEdgeInRotation(edg);\r\n Vertex *adjEdgOtherEnd = adjEdge->GetOtherEnd(end);\r\n directionEdge = adjEdgOtherEnd->GetNextEdgeInRotation(adjEdge);\r\n }\r\n // Store the current face details as prev face details for next face\r\n prevDirectionEdge = edg;\r\n prevFaceKnotType = currTile->knotType;\r\n prevFace = currFace;\r\n prevTile = currTile;\r\n // Update current Face and corresponding Tile variables\r\n start = directionEdge->GetStart();\r\n end = directionEdge->GetEnd();\r\n if( face_map_[start][end] == currFace ) {\r\n Vertex* temp= start;\r\n start = end;\r\n end = temp;\r\n }\r\n currFace = face_map_[start][end];\r\n currTile = tile_map_[currFace];\r\n }\r\n else if( currTile->visited == 1 )\r\n {\r\n Edge *edg = 0;\r\n Vertex *start = 0;\r\n Vertex *end = 0;\r\n bool isCurve1,isReverse;\r\n\r\n if(directionEdge==0) {\r\n // Loop over the edges to find an edge which emits an unvisited curve\r\n std::vector currFaceEdges = currFace->GetEdges();\r\n for( std::vector::iterator e = currFaceEdges.begin(); e!=currFaceEdges.end(); e++ )\r\n {\r\n Edge* tmp = *e;\r\n start = tmp->GetStart();\r\n end = tmp->GetEnd();\r\n if( face_map_[start][end] != currFace ) {\r\n Vertex* temp= start;\r\n start = end;\r\n end = temp;\r\n }\r\n currTile->findCurveAndDirection(start,end,isCurve1,isReverse);\r\n if((currTile->isCrv1Used == YES && isCurve1) || (currTile->isCrv2Used == YES && !isCurve1))\r\n continue;\r\n else {\r\n edg = tmp;\r\n break;\r\n }\r\n }\r\n }\r\n else {// Use the common edge from prev step\r\n edg = directionEdge;\r\n start = edg->GetStart();\r\n end = edg->GetEnd();\r\n if( face_map_[start][end] != currFace ) {\r\n Vertex* temp = start;\r\n start = end;\r\n end = temp;\r\n }\r\n currTile->findCurveAndDirection(start,end,isCurve1,isReverse);\r\n }\r\n\r\n if( (prevFaceKnotType == PLUS1 || prevFaceKnotType == PLUS2) &&\r\n (currTile->knotType == PLUS1 || currTile->knotType == PLUS2) )\r\n {\r\n if((currTile->isCrv1Used == YES && isCurve1) ||\r\n (currTile->isCrv2Used == YES && !isCurve1))\r\n {\r\n if( prevFaceKnotType==currTile->knotType )\r\n {\r\n // Remove already pushed curve vertices\r\n for(unsigned int rem=0; rem<3; rem++)\r\n currCrv.myPnts.pop_back();\r\n // Change prev face KNOT type; choose TWIST1\r\n prevTile->knotType = TWIST1;\r\n prevTile->visited--;\r\n // Now reset the state variables to prev state and continue with new KNOT type.\r\n // Don't change the visited of the currTile\r\n prevFaceKnotType = TWIST1;\r\n currFace = prevFace;\r\n currTile = prevTile;\r\n directionEdge = prevDirectionEdge;\r\n } else {\r\n // This is one special case where we should close curve\r\n // since we entered the face along the edge we started the curve\r\n // for(int i=0;i<1;i++) {\r\n currCrv.myPnts.push_back(currCrv.myPnts[0]);\r\n currCrv.derivatives.push_back(currCrv.derivatives[0]);\r\n currCrv.triadNorms.push_back(currCrv.triadNorms[0]);\r\n // }\r\n currCurve = false;\r\n wngCrvs.push_back(currCrv);\r\n }\r\n }\r\n else\r\n {\r\n // If curve we are gng to use is not used yet; just proceed in normal fashion\r\n // Add points and compute next direction and update prev* variables\r\n if(isCurve1) {\r\n if(isReverse) {\r\n /*for( std::vector::reverse_iterator iter = currTile->curve1.rbegin(); iter != currTile->curve1.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);*/\r\n for( int crv=currTile->curve1.size()-2; crv>0; crv--)\r\n currCrv.myPnts.push_back(currTile->curve1[crv]);\r\n Vector3D *derv = new Vector3D((*(*currTile->curve1.begin()))-(*(*currTile->curve1.rbegin())));\r\n derv->normalize();\r\n currCrv.derivatives.push_back(derv);\r\n } else {\r\n /*for( std::vector::iterator iter = currTile->curve1.begin(); iter != currTile->curve1.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);*/\r\n for( int crv=1; crvcurve1.size()-1; crv++)\r\n currCrv.myPnts.push_back(currTile->curve1[crv]);\r\n Vector3D *derv = new Vector3D((*(*currTile->curve1.rbegin()))-(*(*currTile->curve1.begin())));\r\n derv->normalize();\r\n currCrv.derivatives.push_back(derv);\r\n }\r\n currTile->isCrv1Used = YES;\r\n } else {\r\n if(isReverse) {\r\n /*for( std::vector::reverse_iterator iter = currTile->curve2.rbegin(); iter != currTile->curve2.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);*/\r\n for( int crv=currTile->curve2.size()-2; crv>0; crv--)\r\n currCrv.myPnts.push_back(currTile->curve2[crv]);\r\n Vector3D *derv = new Vector3D((*(*currTile->curve2.begin()))-(*(*currTile->curve2.rbegin())));\r\n derv->normalize();\r\n currCrv.derivatives.push_back(derv);\r\n } else {\r\n /*for( std::vector::iterator iter = currTile->curve2.begin(); iter != currTile->curve2.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);*/\r\n for( int crv=1; crvcurve2.size()-1; crv++)\r\n currCrv.myPnts.push_back(currTile->curve2[crv]);\r\n Vector3D *derv = new Vector3D((*(*currTile->curve2.rbegin()))-(*(*currTile->curve2.begin())));\r\n derv->normalize();\r\n currCrv.derivatives.push_back(derv);\r\n }\r\n currTile->isCrv2Used = YES;\r\n }\r\n currCrv.triadNorms.push_back(fNormals_[currFace]);\r\n currTile->visited++;\r\n // Store the current face details as prev face details for next face\r\n prevDirectionEdge = edg;\r\n prevFaceKnotType = currTile->knotType;\r\n prevFace = currFace;\r\n prevTile = currTile;\r\n // compute next direction\r\n Edge* adjEdge = end->GetNextEdgeInRotation(edg);\r\n Vertex *adjEdgOtherEnd = adjEdge->GetOtherEnd(end);\r\n directionEdge = adjEdgOtherEnd->GetNextEdgeInRotation(adjEdge);\r\n // Update current Face and corresponding Tile variables\r\n start = directionEdge->GetStart();\r\n end = directionEdge->GetEnd();\r\n if( face_map_[start][end] == currFace ) {\r\n Vertex* temp = start;\r\n start = end;\r\n end = temp;\r\n }\r\n currFace = face_map_[start][end];\r\n currTile = tile_map_[currFace];\r\n }\r\n }\r\n else\r\n {\r\n currTile->findCurveAndDirection(start,end,isCurve1,isReverse);\r\n if(currTile->knotType == TWIST1)\r\n currTile->generateTwist1Points();\r\n else if(currTile->knotType == TWIST2)\r\n currTile->generateTwist2Points();\r\n\r\n if(isCurve1) {\r\n if(isReverse) {\r\n /*for( std::vector::reverse_iterator iter = currTile->curve1.rbegin(); iter != currTile->curve1.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);*/\r\n for( int crv=currTile->curve1.size()-2; crv>0; crv--)\r\n currCrv.myPnts.push_back(currTile->curve1[crv]);\r\n Vector3D *derv = new Vector3D((*(*currTile->curve1.begin()))-(*(*currTile->curve1.rbegin())));\r\n derv->normalize();\r\n currCrv.derivatives.push_back(derv);\r\n } else {\r\n /*for( std::vector::iterator iter = currTile->curve1.begin(); iter != currTile->curve1.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);*/\r\n for( int crv=1; crvcurve1.size()-1; crv++)\r\n currCrv.myPnts.push_back(currTile->curve1[crv]);\r\n Vector3D *derv = new Vector3D((*(*currTile->curve1.rbegin()))-(*(*currTile->curve1.begin())));\r\n derv->normalize();\r\n currCrv.derivatives.push_back(derv);\r\n }\r\n currTile->isCrv1Used = YES;\r\n } else {\r\n if(isReverse) {\r\n /*for( std::vector::reverse_iterator iter = currTile->curve2.rbegin(); iter != currTile->curve2.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);*/\r\n for( int crv=currTile->curve2.size()-2; crv>0; crv--)\r\n currCrv.myPnts.push_back(currTile->curve2[crv]);\r\n Vector3D *derv = new Vector3D((*(*currTile->curve2.begin()))-(*(*currTile->curve2.rbegin())));\r\n derv->normalize();\r\n currCrv.derivatives.push_back(derv);\r\n } else {\r\n /*for( std::vector::iterator iter = currTile->curve2.begin(); iter != currTile->curve2.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);*/\r\n for( int crv=1; crvcurve2.size()-1; crv++)\r\n currCrv.myPnts.push_back(currTile->curve2[crv]);\r\n Vector3D *derv = new Vector3D((*(*currTile->curve2.rbegin()))-(*(*currTile->curve2.begin())));\r\n derv->normalize();\r\n currCrv.derivatives.push_back(derv);\r\n }\r\n currTile->isCrv2Used = YES;\r\n }\r\n currCrv.triadNorms.push_back(fNormals_[currFace]);\r\n currTile->visited++;\r\n // Store the current face details as prev face details for next face\r\n prevDirectionEdge = edg;\r\n prevFaceKnotType = currTile->knotType;\r\n prevFace = currFace;\r\n prevTile = currTile;\r\n\r\n if(currTile->knotType == TWIST1) {\r\n if(isCurve1)\r\n directionEdge = (isReverse==true ? start->GetPreviousEdgeInRotation(edg) : end->GetNextEdgeInRotation(edg));\r\n else\r\n directionEdge = (isReverse==true ? end->GetNextEdgeInRotation(edg) : start->GetPreviousEdgeInRotation(edg));\r\n } else if(currTile->knotType == TWIST2) {\r\n if(isCurve1)\r\n directionEdge = (isReverse==true ? end->GetNextEdgeInRotation(edg) : start->GetPreviousEdgeInRotation(edg));\r\n else\r\n directionEdge = (isReverse==true ? start->GetPreviousEdgeInRotation(edg) : end->GetNextEdgeInRotation(edg));\r\n } else {\r\n Edge* adjEdge = end->GetNextEdgeInRotation(edg);\r\n Vertex *adjEdgOtherEnd = adjEdge->GetOtherEnd(end);\r\n directionEdge = adjEdgOtherEnd->GetNextEdgeInRotation(adjEdge);\r\n }\r\n // Update current Face and corresponding Tile variables\r\n start = directionEdge->GetStart();\r\n end = directionEdge->GetEnd();\r\n if( face_map_[start][end] == currFace ) {\r\n Vertex* temp = start;\r\n start = end;\r\n end = temp;\r\n }\r\n currFace = face_map_[start][end];\r\n currTile = tile_map_[currFace];\r\n }\r\n }\r\n else if( currTile->visited == 2 )\r\n {\r\n // for(int i=0;i<1;i++) {\r\n currCrv.myPnts.push_back(currCrv.myPnts[0]);\r\n currCrv.derivatives.push_back(currCrv.derivatives[0]);\r\n currCrv.triadNorms.push_back(currCrv.triadNorms[0]);\r\n // }\r\n currCurve = false;\r\n wngCrvs.push_back(currCrv);\r\n }\r\n }\r\n }\r\n}\r\n\r\nvoid Mesh::traverseFaces_TWISTS()\r\n{\r\n Face* currFace=0;\r\n Tile* currTile=0;\r\n\r\n while(anyUnvisitedFaces(&currFace,&currTile))\r\n {\r\n bool currCurve=true;\r\n Edge* prevDirectionEdge=0;\r\n KNOT prevFaceKnotType = NOTHING;\r\n Face* prevFace=0;\r\n Tile* prevTile=0;\r\n Edge* directionEdge = 0;\r\n wngCrvCtrlPnts currCrv;\r\n\r\n while(currCurve)\r\n {\r\n if(currTile->visited == 0)\r\n {\r\n Edge *edg;\r\n if(directionEdge==0)\r\n edg = (*(currFace->GetEdges().begin())); // Pick a random edge\r\n else\r\n edg = directionEdge; // Use the common edge identified in previous iteration\r\n Vertex *start = edg->GetStart();\r\n Vertex *end = edg->GetEnd();\r\n if( face_map_[start][end] != currFace ) {\r\n Vertex* temp = start;\r\n start = end;\r\n end = temp;\r\n }\r\n bool isCurve1;\r\n bool isReverse;\r\n if(prevFaceKnotType == currTile->knotType) {\r\n if(currTile->knotType == PLUS1 ) {\r\n currTile->swapCurveMidPoints();\r\n currTile->knotType = PLUS2;\r\n } else if(currTile->knotType == TWIST1) {\r\n currTile->knotType = TWIST2;\r\n currTile->generateTwist2Points();\r\n } else if(currTile->knotType == TWIST2) {\r\n currTile->knotType = TWIST1;\r\n currTile->generateTwist1Points();\r\n }\r\n } else if(currTile->knotType == PLUS1)\r\n currTile->generateCurvePoints();\r\n else if(currTile->knotType == PLUS2)\r\n currTile->swapCurveMidPoints();\r\n else if(currTile->knotType == TWIST1)\r\n currTile->generateTwist1Points();\r\n else if(currTile->knotType == TWIST2)\r\n currTile->generateTwist2Points();\r\n\r\n currTile->findCurveAndDirection(start,end,isCurve1,isReverse);\r\n if(isCurve1) {\r\n if(isReverse) {\r\n for( std::vector::reverse_iterator iter = currTile->curve1.rbegin(); iter != currTile->curve1.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n } else {\r\n for( std::vector::iterator iter = currTile->curve1.begin(); iter != currTile->curve1.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n }\r\n currTile->isCrv1Used = YES;\r\n } else {\r\n if(isReverse) {\r\n for( std::vector::reverse_iterator iter = currTile->curve2.rbegin(); iter != currTile->curve2.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n } else {\r\n for( std::vector::iterator iter = currTile->curve2.begin(); iter != currTile->curve2.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n }\r\n currTile->isCrv2Used = YES;\r\n }\r\n currCrv.triadNorms.push_back(fNormals_[currFace]);\r\n currTile->visited++;\r\n\r\n if(currTile->knotType == TWIST1) {\r\n if(isCurve1)\r\n directionEdge = (isReverse==true ? end->GetNextEdgeInRotation(edg) : start->GetPreviousEdgeInRotation(edg));\r\n else\r\n directionEdge = (isReverse==true ? start->GetPreviousEdgeInRotation(edg) : end->GetNextEdgeInRotation(edg));\r\n } else if(currTile->knotType == TWIST2) {\r\n if(isCurve1)\r\n directionEdge = (isReverse==true ? start->GetPreviousEdgeInRotation(edg) : end->GetNextEdgeInRotation(edg));\r\n else\r\n directionEdge = (isReverse==true ? end->GetNextEdgeInRotation(edg) : start->GetPreviousEdgeInRotation(edg));\r\n } else {\r\n Edge* adjEdge = end->GetNextEdgeInRotation(edg);\r\n Vertex *adjEdgOtherEnd = adjEdge->GetOtherEnd(end);\r\n directionEdge = adjEdgOtherEnd->GetNextEdgeInRotation(adjEdge);\r\n }\r\n // Store the current face details as prev face details for next face\r\n prevDirectionEdge = edg;\r\n prevFaceKnotType = currTile->knotType;\r\n prevFace = currFace;\r\n prevTile = currTile;\r\n // Update current Face and corresponding Tile variables\r\n start = directionEdge->GetStart();\r\n end = directionEdge->GetEnd();\r\n if( face_map_[start][end] == currFace ) {\r\n Vertex* temp = start;\r\n start = end;\r\n end = temp;\r\n }\r\n currFace = face_map_[start][end];\r\n currTile = tile_map_[currFace];\r\n }\r\n else if( currTile->visited == 1 )\r\n {\r\n Edge *edg=0;\r\n Vertex *start=0;\r\n Vertex *end=0;\r\n bool isCurve1;\r\n bool isReverse;\r\n\r\n if(directionEdge==0) {\r\n std::vector currFaceEdges = currFace->GetEdges();\r\n // Loop over the edges until you find an edge from which an unvisited curve is coming out\r\n for( std::vector::iterator e = currFaceEdges.begin(); e!=currFaceEdges.end(); e++ )\r\n {\r\n Edge* tmp = *e;\r\n start = tmp->GetStart();\r\n end = tmp->GetEnd();\r\n if( face_map_[start][end] != currFace ) {\r\n Vertex* temp = start;\r\n start = end;\r\n end = temp;\r\n }\r\n currTile->findCurveAndDirection(start,end,isCurve1,isReverse);\r\n if(!((currTile->isCrv1Used == YES && isCurve1) || (currTile->isCrv2Used == YES && !isCurve1)))\r\n {\r\n edg = tmp;\r\n break;\r\n }\r\n }\r\n }\r\n else {\r\n edg = directionEdge; // Use the common edge identified in previous iteration\r\n start = edg->GetStart();\r\n end = edg->GetEnd();\r\n if( face_map_[start][end] != currFace ) {\r\n Vertex* temp = start;\r\n start = end;\r\n end = temp;\r\n }\r\n currTile->findCurveAndDirection(start,end,isCurve1,isReverse);\r\n }\r\n\r\n\r\n if( ( (prevFaceKnotType == PLUS1 || prevFaceKnotType == PLUS2) && (currTile->knotType == PLUS1 || currTile->knotType == PLUS2) ) ||\r\n ( (prevFaceKnotType == TWIST1 || prevFaceKnotType == TWIST2) && (currTile->knotType == TWIST1 || currTile->knotType == TWIST2) ) )\r\n {\r\n if((currTile->isCrv1Used == YES && isCurve1) || (currTile->isCrv2Used == YES && !isCurve1))\r\n {\r\n if( prevFaceKnotType==currTile->knotType )\r\n {\r\n // Remove already pushed curve vertices\r\n for(unsigned int rem=0; rem<3; rem++)\r\n currCrv.myPnts.pop_back();\r\n // Change prev face KNOT type; choose TWIST1\r\n prevTile->knotType = PLUS1;\r\n prevTile->visited--;\r\n // Now reset the state variables to prev state and continue with new KNOT type.\r\n // Don't change the visited of the currTile\r\n prevFaceKnotType = PLUS1;\r\n currFace = prevFace;\r\n currTile = prevTile;\r\n directionEdge = prevDirectionEdge;\r\n } else {\r\n // This is one special case where we should close curve\r\n // since we entered the face along the edge we started the curve\r\n if(isCurve1) {\r\n if(isReverse) {\r\n for( std::vector::reverse_iterator iter = currTile->curve1.rbegin(); iter != currTile->curve1.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n } else {\r\n for( std::vector::iterator iter = currTile->curve1.begin(); iter != currTile->curve1.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n }\r\n } else {\r\n if(isReverse) {\r\n for( std::vector::reverse_iterator iter = currTile->curve2.rbegin(); iter != currTile->curve2.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n } else {\r\n for( std::vector::iterator iter = currTile->curve2.begin(); iter != currTile->curve2.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n }\r\n }\r\n currCrv.triadNorms.push_back(fNormals_[currFace]);\r\n currCurve = false;\r\n wngCrvs.push_back(currCrv);\r\n }\r\n }\r\n else\r\n {\r\n // If curve we are gng to use is not used yet; just proceed in normal fashion\r\n // Add points and compute next direction and update prev* variables\r\n if(isCurve1) {\r\n if(isReverse) {\r\n for( std::vector::reverse_iterator iter = currTile->curve1.rbegin(); iter != currTile->curve1.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n } else {\r\n for( std::vector::iterator iter = currTile->curve1.begin(); iter != currTile->curve1.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n }\r\n currTile->isCrv1Used = YES;\r\n } else {\r\n if(isReverse) {\r\n for( std::vector::reverse_iterator iter = currTile->curve2.rbegin(); iter != currTile->curve2.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n } else {\r\n for( std::vector::iterator iter = currTile->curve2.begin(); iter != currTile->curve2.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n }\r\n currTile->isCrv2Used = YES;\r\n }\r\n currCrv.triadNorms.push_back(fNormals_[currFace]);\r\n currTile->visited++;\r\n // Store the current face details as prev face details for next face\r\n prevDirectionEdge = edg;\r\n prevFaceKnotType = currTile->knotType;\r\n prevFace = currFace;\r\n prevTile = currTile;\r\n // compute next direction\r\n if(currTile->knotType == TWIST1) {\r\n if(isCurve1)\r\n directionEdge = (isReverse==true ? end->GetNextEdgeInRotation(edg) : start->GetPreviousEdgeInRotation(edg));\r\n else\r\n directionEdge = (isReverse==true ? start->GetPreviousEdgeInRotation(edg) : end->GetNextEdgeInRotation(edg));\r\n } else if(currTile->knotType == TWIST2) {\r\n if(isCurve1)\r\n directionEdge = (isReverse==true ? start->GetPreviousEdgeInRotation(edg) : end->GetNextEdgeInRotation(edg));\r\n else\r\n directionEdge = (isReverse==true ? end->GetNextEdgeInRotation(edg) : start->GetPreviousEdgeInRotation(edg));\r\n } else {\r\n Edge* adjEdge = end->GetNextEdgeInRotation(edg);\r\n Vertex *adjEdgOtherEnd = adjEdge->GetOtherEnd(end);\r\n directionEdge = adjEdgOtherEnd->GetNextEdgeInRotation(adjEdge);\r\n }\r\n // Update current Face and corresponding Tile variables\r\n start = directionEdge->GetStart();\r\n end = directionEdge->GetEnd();\r\n if( face_map_[start][end] == currFace ) {\r\n Vertex* temp = start;\r\n start = end;\r\n end = temp;\r\n }\r\n currFace = face_map_[start][end];\r\n currTile = tile_map_[currFace];\r\n }\r\n }\r\n else\r\n {\r\n currTile->findCurveAndDirection(start,end,isCurve1,isReverse);\r\n /*if(currTile->knotType == TWIST1)\r\n currTile->generateTwist1Points();\r\n else if(currTile->knotType == TWIST2)\r\n currTile->generateTwist2Points();*/\r\n\r\n if(isCurve1) {\r\n if(isReverse) {\r\n for( std::vector::reverse_iterator iter = currTile->curve1.rbegin(); iter != currTile->curve1.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n } else {\r\n for( std::vector::iterator iter = currTile->curve1.begin(); iter != currTile->curve1.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n }\r\n currTile->isCrv1Used = YES;\r\n } else {\r\n if(isReverse) {\r\n for( std::vector::reverse_iterator iter = currTile->curve2.rbegin(); iter != currTile->curve2.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n } else {\r\n for( std::vector::iterator iter = currTile->curve2.begin(); iter != currTile->curve2.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n }\r\n currTile->isCrv2Used = YES;\r\n }\r\n currCrv.triadNorms.push_back(fNormals_[currFace]);\r\n currTile->visited++;\r\n // Store the current face details as prev face details for next face\r\n prevDirectionEdge = edg;\r\n prevFaceKnotType = currTile->knotType;\r\n prevFace = currFace;\r\n prevTile = currTile;\r\n\r\n if(currTile->knotType == TWIST1) {\r\n if(isCurve1)\r\n directionEdge = (isReverse==true ? end->GetNextEdgeInRotation(edg) : start->GetPreviousEdgeInRotation(edg));\r\n else\r\n directionEdge = (isReverse==true ? start->GetPreviousEdgeInRotation(edg) : end->GetNextEdgeInRotation(edg));\r\n } else if(currTile->knotType == TWIST2) {\r\n if(isCurve1)\r\n directionEdge = (isReverse==true ? start->GetPreviousEdgeInRotation(edg) : end->GetNextEdgeInRotation(edg));\r\n else\r\n directionEdge = (isReverse==true ? end->GetNextEdgeInRotation(edg) : start->GetPreviousEdgeInRotation(edg));\r\n } else {\r\n Edge* adjEdge = end->GetNextEdgeInRotation(edg);\r\n Vertex *adjEdgOtherEnd = adjEdge->GetOtherEnd(end);\r\n directionEdge = adjEdgOtherEnd->GetNextEdgeInRotation(adjEdge);\r\n }\r\n // Update current Face and corresponding Tile variables\r\n start = directionEdge->GetStart();\r\n end = directionEdge->GetEnd();\r\n if( face_map_[start][end] == currFace ) {\r\n Vertex* temp = start;\r\n start = end;\r\n end = temp;\r\n }\r\n currFace = face_map_[start][end];\r\n currTile = tile_map_[currFace];\r\n }\r\n }\r\n else if( currTile->visited == 2 )\r\n {\r\n Edge *edg = directionEdge; // Use the common edge identified in previous iteration\r\n Vertex *start = edg->GetStart();\r\n Vertex *end = edg->GetEnd();\r\n if( face_map_[start][end] != currFace ) {\r\n Vertex* temp = start;\r\n start = end;\r\n end = temp;\r\n }\r\n\r\n bool isCurve1;\r\n bool isReverse;\r\n currTile->findCurveAndDirection(start,end,isCurve1,isReverse);\r\n if(isCurve1) {\r\n if(isReverse) {\r\n for( std::vector::reverse_iterator iter = currTile->curve1.rbegin(); iter != currTile->curve1.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n } else {\r\n for( std::vector::iterator iter = currTile->curve1.begin(); iter != currTile->curve1.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n }\r\n } else {\r\n if(isReverse) {\r\n for( std::vector::reverse_iterator iter = currTile->curve2.rbegin(); iter != currTile->curve2.rend(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n } else {\r\n for( std::vector::iterator iter = currTile->curve2.begin(); iter != currTile->curve2.end(); iter++ )\r\n currCrv.myPnts.push_back(*iter);\r\n }\r\n }\r\n currCrv.triadNorms.push_back(fNormals_[currFace]);\r\n currCurve = false;\r\n wngCrvs.push_back(currCrv);\r\n }\r\n }\r\n }\r\n}\r\n\r\n\r\nvoid Mesh::generateCtrlPnts4InterpolationSpline()\r\n{\r\n for (std::vector::iterator crv = wngCrvs.begin(); crv != wngCrvs.end(); ++crv)\r\n {\r\n Vec3DPtrIter vBegin\t\t\t= (*crv).myPnts.begin();\r\n Vec3DPtrIter vEnd\t\t\t= (*crv).myPnts.end();\r\n Vec3DPtrIter dBegin\t\t\t= (*crv).derivatives.begin();\r\n Vec3DPtrIter dEnd\t\t\t= (*crv).derivatives.end();\r\n Vec3DPtrIter nBegin\t\t\t= (*crv).triadNorms.begin();\r\n Vec3DPtrIter nEnd\t\t\t= (*crv).triadNorms.end();\r\n Vector3D *vFinish\t\t\t= *((*crv).myPnts.rbegin()+1);\r\n Vec3DPtrIter dIter\t\t\t= dBegin;\r\n Vec3DPtrIter nIter\t\t\t= nBegin;\r\n\r\n for( Vec3DPtrIter c = vBegin; c+1 != vEnd; ++c, ++dIter, ++nIter )\r\n {\r\n Vector3D P1, P2, P3, P4, b1, b2, derv, norm, binorm;\r\n Vector3D n1 = *(*nIter);\r\n Vector3D n2 = ( c+2 == vEnd ? *(*(nBegin+1)) : *(*(nIter+1)) );\r\n\r\n if( c == vBegin ) {\r\n P1.set( vFinish->DX(), vFinish->DY(), vFinish->DZ() );\r\n P2.set( (*c)->DX(), (*c)->DY(), (*c)->DZ() );\r\n P3.set( (*(c+1))->DX(), (*(c+1))->DY(), (*(c+1))->DZ() );\r\n P4.set( (*(c+2))->DX(), (*(c+2))->DY(), (*(c+2))->DZ() );\r\n } else if( c+2 == vEnd ) {\r\n P1.set( (*(c-3))->DX(), (*(c-3))->DY(), (*(c-3))->DZ() );\r\n P2.set( (*c)->DX(), (*c)->DY(), (*c)->DZ() );\r\n P3.set( (*(c+1))->DX(), (*(c+1))->DY(), (*(c+1))->DZ() );\r\n P4.set( (*(vBegin+3))->DX(), (*(vBegin+3))->DY(), (*(vBegin+3))->DZ() );\r\n } else {\r\n P1.set( (*(c-3))->DX(), (*(c-3))->DY(), (*(c-3))->DZ() );\r\n P2.set( (*c)->DX(), (*c)->DY(), (*c)->DZ() );\r\n P3.set( (*(c+1))->DX(), (*(c+1))->DY(), (*(c+1))->DZ() );\r\n P4.set( (*(c+2))->DX(), (*(c+2))->DY(), (*(c+2))->DZ() );\r\n }\r\n b1 = P2 + (P3 - P1) / 6.0f;\r\n b2 = P3 + (P2 - P4) / 6.0f;\r\n\r\n c++; dIter++; nIter++;\r\n c = (*crv).myPnts.insert(c,new Vector3D(b1));\r\n derv = b2 - P2; derv.normalize();\r\n binorm = cross(derv,n1); binorm.normalize();\r\n norm = cross(binorm,derv); norm.normalize();\r\n dIter = (*crv).derivatives.insert(dIter,new Vector3D(derv));\r\n nIter = (*crv).triadNorms.insert(nIter,new Vector3D(norm));\r\n\r\n c++; dIter++; nIter++;\r\n c = (*crv).myPnts.insert(c,new Vector3D(b2));\r\n derv = P3 - b1; derv.normalize();\r\n binorm = cross(derv,n2); binorm.normalize();\r\n norm = cross(binorm,derv); norm.normalize();\r\n dIter = (*crv).derivatives.insert(dIter,new Vector3D(derv));\r\n nIter = (*crv).triadNorms.insert(nIter,new Vector3D(norm));\r\n\r\n /* Begin and End iterators are no longer valid, hence get updated ones */\r\n vBegin\t= (*crv).myPnts.begin();\r\n vEnd\t= (*crv).myPnts.end();\r\n nBegin\t= (*crv).triadNorms.begin();\r\n }\r\n }\r\n}\r\n\r\n\r\nvoid Mesh::generateKnotVectors(GLfloat *uKnots, GLint uKnotCount, GLfloat *vKnots, GLint vKnotCount)\r\n{\r\n GLfloat step = 1.0;\r\n GLint ktIter = 0;\r\n uKnots[ktIter++]= 0.0f;\r\n for(GLint k=ktIter; k thisCurvePnts = wvngCrv.myPnts;\r\n std::vector thisCurveTriads = wvngCrv.triadNorms;\r\n std::vector thisDervs = wvngCrv.derivatives;\r\n\r\n for(std::vector::iterator it = thisCurvePnts.begin(); it != thisCurvePnts.end(); it++,triadIndex++)\r\n {\r\n Vector3D norm = *thisCurveTriads[triadIndex];\r\n Vector3D derivative = *thisDervs[triadIndex];\r\n norm.normalize();\r\n derivative.normalize();\r\n Vector3D binorm = cross(norm,derivative);\r\n binorm.normalize();\r\n\r\n i = it-thisCurvePnts.begin();\r\n Vector3D tmp = *(*it);\r\n theta = 0.0f;\r\n for(int v=0; v::iterator crv = wngCrvs.begin(); crv != wngCrvs.end(); ++crv)\r\n {\r\n WvngTube *currTube = new WvngTube;\r\n wngCrvCtrlPnts currCurve = (*crv);\r\n currTube->uOrder = DEGREE+1;\r\n currTube->vOrder = DEGREE+1;\r\n currTube->uCtrlNum = currCurve.myPnts.size() + EXTRA_VERTICES;\r\n currTube->vCtrlNum = vNumPnts;\r\n currTube->uStride = currTube->vCtrlNum*DIMENSION;\r\n currTube->vStride = DIMENSION;\r\n currTube->uKnotCount = currTube->uCtrlNum + currTube->uOrder;\r\n currTube->vKnotCount = currTube->vCtrlNum + currTube->vOrder;\r\n currTube->uKnots = new GLfloat[currTube->uKnotCount];\r\n currTube->vKnots = new GLfloat[currTube->vKnotCount];\r\n generateKnotVectors(currTube->uKnots,currTube->uKnotCount,currTube->vKnots,currTube->vKnotCount);\r\n currTube->ctlPoints = new float[currTube->uCtrlNum*currTube->vCtrlNum*DIMENSION];\r\n generateTubeCtrlPnts(currCurve,currTube->ctlPoints);\r\n app::console()<\n\n#include \n#include \n#include \n\n#include \n\ntypedef Eigen::SparseMatrix Matrix;\ntypedef Matrix::InnerIterator MatrixIterator;\ntypedef Eigen::BiCGSTAB > BiCGSTAB;\ntypedef Eigen::LeastSquaresConjugateGradient >\n LeastSqCG;\ntypedef Eigen::SparseLU > SparseLU;\n\nPnm::Pnm(const std::map > ¶msPnm,\n std::shared_ptr netgrid) :\n _paramsPnm(paramsPnm),\n _netgrid(netgrid),\n _dim(netgrid->_poresPores.size()),\n _matrix(_dim, _dim),\n _freeVector(new double[_dim], _dim),\n _pressures(new double[_dim], _dim) {}\n\nvoid Pnm::printParamsPnm() {\n\n for (auto const &[name, param] : _paramsPnm) {\n std::cout << name << \": \";\n if (std::get_if(¶m))\n std::cout << std::get(param) << std::endl;\n else if (std::get_if(¶m))\n std::cout << std::get(param) << std::endl;\n else if (std::get_if(¶m))\n std::cout << std::get(param) << std::endl;\n }\n\n}\n\nvoid Pnm::calcConductances(const std::vector &densities,\n const std::vector &viscosities) {\n\n for (auto &[throat, pores] : _netgrid->_throatsPores) {\n\n auto &height = _netgrid->_throatsDepths[throat];\n auto &width = _netgrid->_throatsWidths[throat];\n auto &length = _netgrid->_throatsLs[throat];\n auto &density = densities[throat];\n auto &viscosity = viscosities[throat];\n // 3D case\n // double resistance = 12. * viscosity * length / height / height / height / width;\n // 2D case\n auto corrFactor = 1.12;\n double resistance = corrFactor * 12. * viscosity * length / width / width / width / height;\n\n // _conductances[throat] = density / resistance;\n _conductances[throat] = 1. / resistance;\n }\n\n}\n\nvoid Pnm::processThroats() {\n for (auto&[throat, pores] : _netgrid->_throatsPores) {\n auto &normals = _netgrid->_normalsThroatsPores[throat];\n for (uint32_t i = 0; i < pores.size(); i++)\n _matrixCoeffs[throat][pores[i]] = normals[i] * _conductances[throat];\n }\n}\n\nvoid Pnm::processPores() {\n\n for (auto &pore: _netgrid->_inletPores)\n _freeCoeffs[pore] = 0;\n for (auto &pore: _netgrid->_outletPores)\n _freeCoeffs[pore] = 0;\n for (auto &pore: _netgrid->_deadendPores)\n _freeCoeffs[pore] = 0;\n for (auto &pore: _netgrid->_nonboundPores)\n _freeCoeffs[pore] = 0;\n}\n\nvoid Pnm::processNewmanPores(std::map &poresFlows) {\n // ToDo: make sure it is ok with flow sign\n for (auto &[pore, flow]: poresFlows)\n _freeCoeffs[pore] = flow;\n}\n\nvoid Pnm::processDirichPores(std::map &poresPressures) {\n for (auto &[pore, pressure]: poresPressures)\n _freeCoeffs[pore] = pressure;\n}\n\nvoid Pnm::fillMatrix(std::map &poresFlows,\n std::map &poresPressures,\n const std::vector &capillaryPressures) {\n\n for (int i = 0; i < _dim; ++i)\n for (MatrixIterator it(_matrix, i); it; ++it)\n it.valueRef() = 0;\n\n std::set groupedPores;\n groupedPores.insert(_netgrid->_nonboundPores.begin(), _netgrid->_nonboundPores.end());\n groupedPores.insert(_netgrid->_deadendPores.begin(), _netgrid->_deadendPores.end());\n\n for (auto &pore: groupedPores) {\n _freeVector[pore] = _freeCoeffs[pore];\n auto &throats = _netgrid->_poresThroats[pore];\n auto &normals = _netgrid->_normalsPoresThroats[pore];\n for (uint32_t i = 0; i < throats.size(); i++) {\n _freeVector[pore] += normals[i] * _conductances[throats[i]] *\n capillaryPressures[throats[i]];\n for (auto &poreCurr : _netgrid->_throatsPores[throats[i]])\n _matrix.coeffRef(pore, poreCurr) +=\n normals[i] * _matrixCoeffs[throats[i]][poreCurr];\n }\n }\n\n for (auto &[pore, flow]: poresFlows) {\n _freeVector[pore] = _freeCoeffs[pore];\n auto &throats = _netgrid->_poresThroats[pore];\n auto &normals = _netgrid->_normalsPoresThroats[pore];\n for (uint32_t i = 0; i < throats.size(); i++) {\n _freeVector[pore] += normals[i] * _conductances[throats[i]] *\n capillaryPressures[throats[i]];\n for (auto &poreCurr : _netgrid->_throatsPores[throats[i]])\n _matrix.coeffRef(pore, poreCurr) +=\n normals[i] * _matrixCoeffs[throats[i]][poreCurr];\n }\n }\n\n for (auto &[pore, pressure]: poresPressures) {\n _freeVector[pore] = _freeCoeffs[pore];\n _matrix.coeffRef(pore, pore) = 1;\n }\n\n}\n\nvoid Pnm::calculatePress() {\n\n auto &itAccuracy = std::get(_paramsPnm[\"it_accuracy\"]);\n auto &solverMethod = std::get(_paramsPnm[\"solver_method\"]);\n\n if (solverMethod == \"sparseLU\") {\n\n SparseLU sparseLU;\n sparseLU.compute(_matrix);\n _pressures = sparseLU.solve(_freeVector);\n\n } else if (solverMethod == \"biCGSTAB\") {\n\n BiCGSTAB biCGSTAB;\n biCGSTAB.compute(_matrix);\n biCGSTAB.setTolerance(itAccuracy);\n _pressures = biCGSTAB.solveWithGuess(_freeVector, _pressures);\n\n } else if (solverMethod == \"leastSqCG\") {\n\n LeastSqCG leastSqCG;\n leastSqCG.compute(_matrix);\n leastSqCG.setTolerance(itAccuracy);\n _pressures = leastSqCG.solveWithGuess(_freeVector, _pressures);\n\n }\n\n}\n\nvoid Pnm::cfdProcedure(const std::vector &densities,\n const std::vector &viscosities,\n const std::vector &capillaryPressures,\n std::map &poresFlows,\n std::map &poresPressures) {\n\n calcConductances(densities, viscosities);\n processThroats();\n processPores();\n processNewmanPores(poresFlows);\n processDirichPores(poresPressures);\n fillMatrix(poresFlows, poresPressures, capillaryPressures);\n // std::cout << _matrix << std::endl;\n\n calculatePress();\n\n}\n\nvoid Pnm::calcThroatsVolFlows(const std::vector &capillaryPressures) {\n\n for (auto &[throat, conductance] : _conductances) {\n auto &pores = _netgrid->_throatsPores[throat];\n auto &normals = _netgrid->_normalsThroatsPores[throat];\n _throatsVolFlows[throat] = conductance * capillaryPressures[throat];\n for (uint32_t i = 0; i < pores.size(); i++)\n _throatsVolFlows[throat] -= normals[i] * conductance * _pressures[pores[i]];\n }\n\n}\n\nvoid Pnm::calcPoresFlowRates() {\n\n std::set groupedPores;\n groupedPores.insert(_netgrid->_nonboundPores.begin(), _netgrid->_nonboundPores.end());\n groupedPores.insert(_netgrid->_deadendPores.begin(), _netgrid->_deadendPores.end());\n\n for (auto &pore: groupedPores) {\n auto &poresThroats = _netgrid->_poresThroats[pore];\n auto &normals = _netgrid->_normalsPoresThroats[pore];\n for (uint32_t i = 0; i < poresThroats.size(); i++)\n _poresFlowRates[pore] += normals[i] * _throatsVolFlows[poresThroats[i]];\n }\n\n for (auto &pore: _netgrid->_outletPores) {\n auto &poresThroats = _netgrid->_poresThroats[pore];\n auto &normals = _netgrid->_normalsPoresThroats[pore];\n for (uint32_t i = 0; i < poresThroats.size(); i++)\n _poresFlowRates[pore] += normals[i] * _throatsVolFlows[poresThroats[i]];\n }\n\n for (auto &pore: _netgrid->_inletPores) {\n auto &poresThroats = _netgrid->_poresThroats[pore];\n auto &normals = _netgrid->_normalsPoresThroats[pore];\n for (uint32_t i = 0; i < poresThroats.size(); i++)\n _poresFlowRates[pore] += -normals[i] * _throatsVolFlows[poresThroats[i]];\n }\n\n}\n\nvoid Pnm::calcTotalFlowRate(const std::set &pores) {\n\n _totFlowRate = 0;\n\n for (auto &pore: pores)\n _totFlowRate += _poresFlowRates[pore];\n}\n\nvoid Pnm::setPressures(Eigen::Ref pressures) {\n if (_pressures.data() != pressures.data())\n delete _pressures.data();\n new(&_pressures) Eigen::Map(pressures.data(),\n pressures.size());\n}\n\nEigen::Ref Pnm::getPressures() {\n return _pressures;\n}", "meta": {"hexsha": "beb742b43a4b2407999cf87d6dd9ef9bd4f3d508", "size": 8623, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "pnm/Pnm.cpp", "max_stars_repo_name": "lanetszb/vofpnm", "max_stars_repo_head_hexsha": "520544db894fb13e44a86e989bd17b4690e996d3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pnm/Pnm.cpp", "max_issues_repo_name": "lanetszb/vofpnm", "max_issues_repo_head_hexsha": "520544db894fb13e44a86e989bd17b4690e996d3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pnm/Pnm.cpp", "max_forks_repo_name": "lanetszb/vofpnm", "max_forks_repo_head_hexsha": "520544db894fb13e44a86e989bd17b4690e996d3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.3401639344, "max_line_length": 99, "alphanum_fraction": 0.6218253508, "num_tokens": 2492, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7341195385342971, "lm_q2_score": 0.4765796510636759, "lm_q1q2_score": 0.3498664335137021}} {"text": "/* This file is part of PyMesh. Copyright (c) 2015 by Qingnan Zhou */\n#include \"SelfIntersection.h\"\n\n#include \n#include \n\n#include \n#include \n\n#include \n\nusing namespace PyMesh;\n\nnamespace SelfIntersectionHelper {\n class Box : public CGAL::Box_intersection_d::Box_d {\n public:\n typedef CGAL::Box_intersection_d::Box_d Base;\n typedef Float NT;\n typedef std::size_t ID;\n\n Box() {}\n Box(bool complete) : Base(complete) {}\n Box(NT l[3], NT h[3]) : Base( l, h) {}\n Box( const CGAL::Bbox_3& b) : Base( b) {}\n ID id() const { return m_id; }\n void set_id(ID id) { m_id = id; }\n private:\n ID m_id;\n };\n\n void handle_intersection_candidate(\n SelfIntersection* self, const Box& a, const Box& b) {\n self->handle_intersection_candidate(a.id(), b.id());\n }\n\n Vector2I get_opposite_edge(const Vector3I& f, size_t v) {\n if (f[0] == v) {\n return Vector2I(f[1], f[2]);\n } else if (f[1] == v) {\n return Vector2I(f[2], f[0]);\n } else if (f[2] == v) {\n return Vector2I(f[0], f[1]);\n } else {\n std::stringstream err_msg;\n err_msg << \"Vertex \" << v << \" does not belong to triangle (\"\n << f.transpose() << \")\";\n throw RuntimeError(err_msg.str());\n }\n }\n\n size_t get_opposite_vertex(const Vector3I& f, const Vector2I& e) {\n if (f[0] != e[0] && f[0] != e[1]) return f[0];\n if (f[1] != e[0] && f[1] != e[1]) return f[1];\n if (f[2] != e[0] && f[2] != e[1]) return f[2];\n throw RuntimeError(\"Face must be topologically degnerated!\");\n }\n\n std::vector get_triangle_bboxes(\n const SelfIntersection::Points& pts, const MatrixIr& faces) {\n const size_t num_faces = faces.rows();\n std::vector boxes;\n boxes.reserve(num_faces);\n for (size_t i=0; i corners{\n pts[f[0]], pts[f[1]], pts[f[2]]\n };\n if (CGAL::collinear(pts[f[0]], pts[f[1]], pts[f[2]])) {\n // Triangle is degenerated.\n continue;\n }\n boxes.emplace_back(CGAL::bbox_3(corners.begin(), corners.end()));\n boxes.back().set_id(i);\n }\n return boxes;\n }\n}\nusing namespace SelfIntersectionHelper;\n\nSelfIntersection::SelfIntersection(\n const MatrixFr& vertices, const MatrixIr& faces)\n: m_faces(faces) {\n const size_t num_vertices = vertices.rows();\n const size_t dim = vertices.cols();\n const size_t vertex_per_face = faces.cols();\n\n if (dim != 3) {\n throw NotImplementedError(\n \"Self intersection check only support 3D\");\n }\n if (vertex_per_face != 3) {\n throw NotImplementedError(\n \"Self intersection check only works with triangles\");\n }\n\n m_points.resize(num_vertices);\n for (size_t i=0; i boxes = get_triangle_bboxes(m_points, m_faces);\n boost::function cb =\n boost::bind(SelfIntersectionHelper::handle_intersection_candidate,\n this, _1, _2);\n CGAL::box_self_intersection_d(boxes.begin(), boxes.end(), cb);\n}\n\nvoid SelfIntersection::clear() {\n m_intersecting_pairs.clear();\n}\n\nvoid SelfIntersection::handle_intersection_candidate(\n size_t f_idx_1, size_t f_idx_2) {\n auto duplicated_vertices = topological_overlap(f_idx_1, f_idx_2);\n const Vector3I f1 = m_faces.row(f_idx_1);\n const Vector3I f2 = m_faces.row(f_idx_2);\n const Triangle_3 t1(m_points[f1[0]], m_points[f1[1]], m_points[f1[2]]);\n const Triangle_3 t2(m_points[f2[0]], m_points[f2[1]], m_points[f2[2]]);\n\n bool is_intersecting = false;\n const size_t num_duplicated_vertices = duplicated_vertices.size();\n switch (num_duplicated_vertices) {\n case 0:\n // triangles do not touch.\n {\n bool t1_degenerate = t1.is_degenerate();\n bool t2_degenerate = t2.is_degenerate();\n if (t1_degenerate || t2_degenerate) {\n // Degenerated triangles are considered as\n // self-intersecting.\n is_intersecting = true;\n } else {\n is_intersecting = CGAL::do_intersect(t1, t2);\n }\n }\n break;\n case 3:\n // duplicated face\n is_intersecting = true;\n break;\n case 1:\n {\n // touch at a vertex.\n size_t shared_vertex = duplicated_vertices[0];\n Vector2I opp_edge_1 = get_opposite_edge(f1, shared_vertex);\n Vector2I opp_edge_2 = get_opposite_edge(f2, shared_vertex);\n Segment_3 seg_1(m_points[opp_edge_1[0]], m_points[opp_edge_1[1]]);\n Segment_3 seg_2(m_points[opp_edge_2[0]], m_points[opp_edge_2[1]]);\n is_intersecting =\n CGAL::do_intersect(t1, seg_2) ||\n CGAL::do_intersect(t2, seg_1);\n }\n break;\n case 2:\n {\n // touch at an edge.\n Vector2I shared_edge(duplicated_vertices[0],\n duplicated_vertices[1]);\n size_t v1 = get_opposite_vertex(f1, shared_edge);\n size_t v2 = get_opposite_vertex(f2, shared_edge);\n const auto& p1 = m_points[v1];\n const auto& p2 = m_points[v2];\n const auto& p3 = m_points[shared_edge[0]];\n const auto& p4 = m_points[shared_edge[1]];\n if (CGAL::coplanar(p1, p2, p3, p4)) {\n if (CGAL::collinear(p3, p4, p1)) {\n is_intersecting = true;\n } else if (CGAL::collinear(p3, p4, p2)) {\n is_intersecting = true;\n } else {\n switch (CGAL::coplanar_orientation(p3, p4, p1, p2)) {\n case CGAL::POSITIVE:\n is_intersecting = true;\n break;\n case CGAL::NEGATIVE:\n is_intersecting = false;\n break;\n case CGAL::COLLINEAR:\n throw RuntimeError(\n \"Inconsistent CGAL predicate output\");\n break;\n }\n }\n } else {\n is_intersecting = false;\n }\n }\n break;\n default:\n throw RuntimeError(\n \"Two triangles sharing more than 3 vertices? Something is very wrong\");\n }\n\n if (is_intersecting) {\n m_intersecting_pairs.emplace_back(f_idx_1, f_idx_2);\n }\n}\n\nstd::vector SelfIntersection::topological_overlap(size_t id1, size_t id2) const {\n Vector3I f1 = m_faces.row(id1);\n Vector3I f2 = m_faces.row(id2);\n std::vector duplicated_vertices;\n duplicated_vertices.reserve(3);\n for (size_t i=0; i<3; i++) {\n for (size_t j=0; j<3; j++) {\n if (f1[i] == f2[j]) {\n duplicated_vertices.push_back(f1[i]);\n }\n }\n }\n return duplicated_vertices;\n}\n", "meta": {"hexsha": "8e5ac6e0b42e9f2ca2f9fef7116ed40b75e0bf13", "size": 8023, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "dependencies/PyMesh/tools/CGAL/SelfIntersection.cpp", "max_stars_repo_name": "aprieels/3D-watermarking-spectral-decomposition", "max_stars_repo_head_hexsha": "dcab78857d0bb201563014e58900917545ed4673", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2018-06-04T19:52:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-22T09:04:00.000Z", "max_issues_repo_path": "dependencies/PyMesh/tools/CGAL/SelfIntersection.cpp", "max_issues_repo_name": "aprieels/3D-watermarking-spectral-decomposition", "max_issues_repo_head_hexsha": "dcab78857d0bb201563014e58900917545ed4673", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "dependencies/PyMesh/tools/CGAL/SelfIntersection.cpp", "max_forks_repo_name": "aprieels/3D-watermarking-spectral-decomposition", "max_forks_repo_head_hexsha": "dcab78857d0bb201563014e58900917545ed4673", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.3031674208, "max_line_length": 91, "alphanum_fraction": 0.5232456687, "num_tokens": 1920, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7341195269001831, "lm_q2_score": 0.47657965106367595, "lm_q1q2_score": 0.34986642796912015}} {"text": "#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace Euclid\n{\n\ntemplate\nvoid proxy_view(const Mesh& mesh,\n const ViewSphere& view_sphere,\n std::vector& view_scores,\n float weight)\n{\n using Point_3 = typename boost::property_traits<\n typename boost::property_map::type>::value_type;\n using Kernel = typename CGAL::Kernel_traits::Kernel;\n const int proxies = 6;\n const int width = 256;\n const int height = 256;\n const float least_visible =\n std::cos(boost::math::float_constants::pi / 3.0f);\n const float w1 = weight; // weight for projected areas\n const float w2 = 1.0f - w1; // weight for visible ratios\n\n auto [vbeg, vend] = vertices(mesh);\n auto mesh_vpmap = get(boost::vertex_point, mesh);\n OBB obb;\n obb.build(vbeg, vend, mesh_vpmap);\n\n // Compute projected area\n std::vector positions;\n std::vector indices;\n extract_mesh<3>(mesh, positions, indices);\n positions.push_back(0.0f); // Embree alignment\n RayTracer raytracer;\n raytracer.attach_geometry_buffers(positions, indices);\n\n std::vector projected_areas(proxies);\n for (size_t i = 0; i < projected_areas.size(); ++i) {\n OrthoRayCamera cam;\n auto view_dir = view_sphere.radius * obb.axis(i % 3);\n if (i >= 3) {\n view_dir = -view_dir;\n }\n Eigen::Vector3f pos, focus, up;\n cgal_to_eigen(view_sphere.center + view_dir, pos);\n cgal_to_eigen(view_sphere.center, focus);\n cgal_to_eigen(obb.axis((i + 1) % 3), up);\n cam.lookat(pos, focus, up);\n cam.set_extent(view_sphere.radius * 2.0f, view_sphere.radius * 2.0f);\n\n std::vector pixels(width * height, 0);\n raytracer.render_silhouette(pixels, cam, width, height);\n auto proj = 0;\n for (size_t j = 0; j < pixels.size(); ++j) {\n if (pixels[j] != 0) {\n ++proj;\n }\n }\n projected_areas[i] = static_cast(proj) / pixels.size();\n }\n auto max_proj_area =\n *std::max_element(projected_areas.begin(), projected_areas.end());\n for (auto& proj_area : projected_areas) {\n proj_area /= max_proj_area;\n }\n\n // Compute visible ratio\n std::vector visible_ratios(proxies);\n std::vector n_visible_facets(proxies, 0);\n for (const auto& f : faces(mesh)) {\n auto normal = face_normal(f, mesh);\n if (normal * obb.axis(0) > least_visible) {\n ++n_visible_facets[0];\n }\n if (normal * obb.axis(1) > least_visible) {\n ++n_visible_facets[1];\n }\n if (normal * obb.axis(2) > least_visible) {\n ++n_visible_facets[2];\n }\n if (-normal * obb.axis(0) > least_visible) {\n ++n_visible_facets[3];\n }\n if (-normal * obb.axis(1) > least_visible) {\n ++n_visible_facets[4];\n }\n if (-normal * obb.axis(2) > least_visible) {\n ++n_visible_facets[5];\n }\n }\n float inv_nf = 1.0f / num_faces(mesh);\n std::transform(n_visible_facets.begin(),\n n_visible_facets.end(),\n visible_ratios.begin(),\n [inv_nf](int nf) { return nf * inv_nf; });\n auto max_visible_ratio =\n *std::max_element(visible_ratios.begin(), visible_ratios.end());\n for (auto& visible_ratio : visible_ratios) {\n visible_ratio /= max_visible_ratio;\n }\n\n // Compute final score\n view_scores.clear();\n view_scores.resize(num_vertices(view_sphere.mesh), 0.0f);\n auto sphere_vpmap = get(boost::vertex_point, view_sphere.mesh);\n auto sphere_vimap = get(boost::vertex_index, view_sphere.mesh);\n for (const auto& v : vertices(view_sphere.mesh)) {\n auto view_dir = normalized(get(sphere_vpmap, v) - obb.center());\n auto i = get(sphere_vimap, v);\n view_scores[i] += (w1 * projected_areas[0] + w2 * visible_ratios[0]) *\n std::max(view_dir * obb.axis(0), 0.0f);\n view_scores[i] += (w1 * projected_areas[1] + w2 * visible_ratios[1]) *\n std::max(view_dir * obb.axis(1), 0.0f);\n view_scores[i] += (w1 * projected_areas[2] + w2 * visible_ratios[2]) *\n std::max(view_dir * obb.axis(2), 0.0f);\n view_scores[i] += (w1 * projected_areas[3] + w2 * visible_ratios[3]) *\n std::max(-view_dir * obb.axis(0), 0.0f);\n view_scores[i] += (w1 * projected_areas[4] + w2 * visible_ratios[4]) *\n std::max(-view_dir * obb.axis(1), 0.0f);\n view_scores[i] += (w1 * projected_areas[5] + w2 * visible_ratios[5]) *\n std::max(-view_dir * obb.axis(2), 0.0f);\n }\n}\n\n} // namespace Euclid\n", "meta": {"hexsha": "a6b3dd9f3d2e904137a0b48d26015f222d1e5cd4", "size": 5174, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "include/Euclid/ViewSelection/src/ProxyView.cpp", "max_stars_repo_name": "unclejimbo/euclid", "max_stars_repo_head_hexsha": "e118abdcdf51b6bc05cf5aa056bf228e052cf501", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 31.0, "max_stars_repo_stars_event_min_datetime": "2017-05-02T07:04:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-31T10:00:01.000Z", "max_issues_repo_path": "include/Euclid/ViewSelection/src/ProxyView.cpp", "max_issues_repo_name": "unclejimbo/euclid", "max_issues_repo_head_hexsha": "e118abdcdf51b6bc05cf5aa056bf228e052cf501", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/Euclid/ViewSelection/src/ProxyView.cpp", "max_forks_repo_name": "unclejimbo/euclid", "max_forks_repo_head_hexsha": "e118abdcdf51b6bc05cf5aa056bf228e052cf501", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2018-07-02T17:59:35.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-18T07:01:17.000Z", "avg_line_length": 38.3259259259, "max_line_length": 79, "alphanum_fraction": 0.5873598763, "num_tokens": 1379, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7718434978390747, "lm_q2_score": 0.45326184801538616, "lm_q1q2_score": 0.34984721020919873}} {"text": "#include \"scaled_variance.h\"\n\n#include \"smash/../../scatteractionsfinder.cc\"\n\n#include \n#include \n#include \n\n/// Loads particle table from SMASH\nbool load_particle_types() {\n std::cout << \"Loading SMASH particle types and decay modes\" << std::endl;\n std::string smash_dir(std::getenv(\"SMASH_DIR\"));\n if (smash_dir == \"\") {\n std::cerr << \"Failed to load SMASH particle types. SMASH_DIR is not set.\"\n << std::endl;\n return true;\n }\n std::ifstream particles_input_file(smash_dir + \"/input/particles.txt\");\n std::stringstream buffer;\n if (particles_input_file) {\n buffer << particles_input_file.rdbuf();\n smash::ParticleType::create_type_list(buffer.str());\n } else {\n std::cerr << \"File with SMASH particle list not found.\" << std::endl;\n return true;\n }\n std::ifstream decaymodes_input_file(smash_dir + \"/input/decaymodes.txt\");\n if (decaymodes_input_file) {\n buffer.clear();\n buffer.str(std::string());\n buffer << decaymodes_input_file.rdbuf();\n smash::DecayModes::load_decaymodes(buffer.str());\n smash::ParticleType::check_consistency();\n } else {\n std::cerr << \"File with SMASH decaymodes not found.\" << std::endl;\n return true;\n }\n return false;\n}\n\n\n\nint ScaledVarianceCalculator::set_eos_solver_equations(\n const gsl_vector* x, void* params,\n gsl_vector* f) {\n smash::ParticleTypePtrList* types =\n reinterpret_cast(params)->types;\n double e = reinterpret_cast(params)->e;\n double nb = reinterpret_cast(params)->nb;\n double ns = reinterpret_cast(params)->ns;\n double nq = reinterpret_cast(params)->nq;\n\n const double T = gsl_vector_get(x, 0);\n const double mub = gsl_vector_get(x, 1);\n const double mus = gsl_vector_get(x, 2);\n const double muq = gsl_vector_get(x, 3);\n\n double e_tot = 0.0, nb_tot = 0.0, ns_tot = 0.0, nq_tot = 0.0;\n for (const smash::ParticleTypePtr t : (*types)) {\n const double b = t->baryon_number();\n const double s = t->strangeness();\n const double q = t->charge();\n const double z = t->mass() / T;\n const double mu = mub * b + mus * s + muq * q;\n const double mu_m_over_T = (mu - t->mass()) / T;\n const double factor = t->pdgcode().spin_degeneracy() * 4.0 * M_PI *\n std::pow(T / (2.0 * M_PI * smash::hbarc), 3);\n const double k1 = gsl_sf_bessel_Kn_scaled(1, z);\n const double k2 = gsl_sf_bessel_Kn_scaled(2, z);\n const double ex = std::exp(mu_m_over_T);\n double rho = z * z * k2 * ex * factor;\n double edens = z * z * (3 * k2 + z * k1) * ex * T * factor;\n e_tot += edens;\n nb_tot += rho * b;\n ns_tot += rho * s;\n nq_tot += rho * q;\n }\n gsl_vector_set(f, 0, e_tot - e);\n gsl_vector_set(f, 1, nb_tot - nb);\n gsl_vector_set(f, 2, ns_tot - ns);\n gsl_vector_set(f, 3, nq_tot - nq);\n return GSL_SUCCESS;\n}\n\nstd::string ScaledVarianceCalculator::print_solver_state(size_t iter,\n gsl_multiroot_fsolver* solver) const {\n std::stringstream s;\n // clang-format off\n s << \"iter = \" << iter << \",\"\n << \" x = \" << gsl_vector_get(solver->x, 0) << \" \"\n << gsl_vector_get(solver->x, 1) << \" \"\n << gsl_vector_get(solver->x, 2) << \" \"\n << gsl_vector_get(solver->x, 3) << \", \"\n << \"f(x) = \" << gsl_vector_get(solver->f, 0) << \" \"\n << gsl_vector_get(solver->f, 1) << \" \"\n << gsl_vector_get(solver->f, 2) << \" \"\n << gsl_vector_get(solver->f, 3) << \" \"\n << std::endl;\n // clang-format on\n return s.str();\n\n}\n\nvoid ScaledVarianceCalculator::setTmu_from_conserved(double Etot, double V,\n double B, double S, double Q) {\n if (quantum_statistics_) {\n std::cout << \"WARNING: quantum statistics requested, but not implemented \"\n << \"for (E, B, S, Q) -> (T, muB, muS, muQ) solver.\" << std::endl;\n throw std::runtime_error(\"\");\n }\n const gsl_multiroot_fsolver_type *solver_type = gsl_multiroot_fsolver_hybrid;\n gsl_multiroot_fsolver* solver = gsl_multiroot_fsolver_alloc(solver_type, 4);\n gsl_vector* x = gsl_vector_alloc(4);\n int residual_status = GSL_SUCCESS;\n size_t iter = 0;\n std::cout << print_solver_state(iter, solver);\n\n struct solver_params p = {&all_types_in_the_box_, Etot/V, B/V, S/V, Q/V};\n gsl_multiroot_function f = {&set_eos_solver_equations, 4, &p};\n\n gsl_vector_set(x, 0, 0.15);\n gsl_vector_set(x, 1, 0.01);\n gsl_vector_set(x, 2, 0.01);\n gsl_vector_set(x, 3, 0.01);\n\n gsl_multiroot_fsolver_set(solver, &f, x);\n do {\n iter++;\n const auto iterate_status = gsl_multiroot_fsolver_iterate(solver);\n // std::cout << print_solver_state(iter, solver);\n\n // Avoiding too low temperature\n if (gsl_vector_get(solver->x, 0) < 0.015) {\n T_ = 0.0;\n mub_ = 0.0;\n mus_ = 0.0;\n muq_ = 0.0;\n return;\n }\n\n // check if solver is stuck\n if (iterate_status) {\n break;\n }\n residual_status = gsl_multiroot_test_residual(solver->f, 1.e-9);\n } while (residual_status == GSL_CONTINUE && iter < 1000);\n\n if (residual_status != GSL_SUCCESS) {\n std::stringstream solver_parameters;\n solver_parameters << \"Solver run with \"\n << \"e = \" << Etot/V << \", nb = \" << B/V\n << \", ns = \" << S/V << \", nq = \" << Q/V\n << std::endl;\n throw std::runtime_error(gsl_strerror(residual_status) +\n solver_parameters.str() +\n print_solver_state(iter, solver));\n }\n T_ = gsl_vector_get(solver->x, 0);\n mub_ = gsl_vector_get(solver->x, 1);\n mus_ = gsl_vector_get(solver->x, 2);\n muq_ = gsl_vector_get(solver->x, 3);\n gsl_multiroot_fsolver_free(solver);\n gsl_vector_free(x);\n}\n\nstd::pair ScaledVarianceCalculator::scaled_variance(\n std::function type_of_interest) {\n\n constexpr unsigned int m = 5;\n Eigen::MatrixXd k2_tilde = Eigen::MatrixXd::Zero(m, m);\n double kappa1 = 0.0;\n\n for (const smash::ParticleTypePtr ptype : all_types_in_the_box_) {\n const double b = B_conservation_ ? ptype->baryon_number() : 0;\n const double s = S_conservation_ ? ptype->strangeness() : 0;\n const double q = Q_conservation_ ? ptype->charge() : 0;\n const double z = ptype->mass() / T_;\n const double mu = mub_ * b + mus_ * s + muq_ * q;\n const double mu_m_over_T = (mu - ptype->mass()) / T_;\n if (mu_m_over_T > 0 and quantum_statistics_) {\n std::cout << \"Warning: quantum expressions for \" << ptype->name() <<\n \" do not converge, m < chemical potential.\" << std::endl;\n }\n const double factor = ptype->pdgcode().spin_degeneracy() * 4.0 * M_PI *\n std::pow(T_ / (2.0 * M_PI * smash::hbarc), 3);\n double EE = 0.0, EN = 0.0, NN = 0.0, N1 = 0.0;\n // std::cout << \"Computing matrix for \" << ptype.name() << std::endl;\n for (unsigned int k = 1; k < quantum_series_max_terms_; k++) {\n if (k > 1 and !quantum_statistics_) {\n break;\n }\n const double k1 = gsl_sf_bessel_Kn_scaled(1, z * k);\n const double k2 = gsl_sf_bessel_Kn_scaled(2, z * k);\n const double x = std::exp(mu_m_over_T * k);\n double N1_summand = z * z / k * k2 * x;\n double NN_summand = z * z * k2 * x;\n double EN_summand = z * z / k * (3 * k2 + k * z * k1) * x;\n double EE_summand = z * z / (k * k) *\n ((z * z * k * k + 12.0) * k2 + 3.0 * z * k * k1) * x;\n // std::cout << \"k = \" << k\n // << \", N1_summand*factor*1000 = \" << N1_summand*factor*1000\n // << \", NN_summand*factor*1000 = \" << NN_summand*factor*1000\n // << \", EN_summand = \" << EN_summand\n // << \", EE_summand = \" << EE_summand << std::endl;\n if (k > 1 and\n EE_summand < EE * quantum_series_rel_precision_ and\n EN_summand < EN * quantum_series_rel_precision_ and\n NN_summand < NN * quantum_series_rel_precision_ and\n N1_summand < N1 * quantum_series_rel_precision_) {\n break;\n }\n if (k % 2 == 0 and ptype->pdgcode().is_baryon()) {\n NN_summand = -NN_summand;\n EN_summand = -EN_summand;\n EE_summand = -EE_summand;\n N1_summand = -N1_summand;\n }\n NN += NN_summand;\n EN += EN_summand;\n EE += EE_summand;\n N1 += N1_summand;\n }\n EE *= factor;\n EN *= factor;\n NN *= factor;\n N1 *= factor;\n\n Eigen::MatrixXd k2_tilde_ptype(m, m);\n // clang-format off\n k2_tilde_ptype << NN, EN, q*NN, b*NN, s*NN,\n EN, EE, q*EN, b*EN, s*EN,\n q*NN, q*EN, q*q*NN, q*b*NN, q*s*NN,\n b*NN, b*EN, b*q*NN, b*b*NN, b*s*NN,\n s*NN, s*EN, s*q*NN, s*b*NN, s*s*NN;\n // clang-format on\n if (!type_of_interest(ptype)) {\n k2_tilde_ptype.row(0).setZero();\n k2_tilde_ptype.col(0).setZero();\n N1 = 0.0;\n }\n kappa1 += N1;\n k2_tilde += k2_tilde_ptype;\n }\n\n if (!energy_conservation_) {\n k2_tilde.row(1).setZero();\n k2_tilde.col(1).setZero();\n }\n // Remove zero rows and columns before asking for determinant\n // This uses the property of k2_tilde matrix being symmetric\n Eigen::Matrix non_zeros =\n k2_tilde.cast().colwise().any();\n const unsigned int n = non_zeros.count();\n Eigen::MatrixXd k2_tilde_nz(n, n);\n int i = 0, j;\n for (unsigned int i0 = 0; i0 < m; ++i0) {\n if (!non_zeros(i0)) {\n continue;\n }\n j = 0;\n for (unsigned int j0 = 0; j0 < m; ++j0) {\n if (non_zeros(j0)) {\n k2_tilde_nz(i, j) = k2_tilde(i0, j0);\n j++;\n }\n }\n i++;\n }\n\n const double rho_type_interest = kappa1;\n // No conservation laws: grand-canonical case\n if (n < 2) {\n return std::make_pair(rho_type_interest,\n k2_tilde_nz(0,0) / kappa1);\n }\n\n const double det_k2_tilde = k2_tilde_nz.determinant();\n const double det_k2 = k2_tilde_nz.block(1, 1, n - 1, n - 1).determinant();\n const double expected_scaled_variance = det_k2_tilde / det_k2 /\n rho_type_interest;\n return std::make_pair(rho_type_interest, expected_scaled_variance);\n}\n\nvoid ScaledVarianceCalculator::prepare_decays() {\n std::vector all_stable_hadrons;\n for (const smash::ParticleType &ptype : smash::ParticleType::list_all()) {\n if (ptype.is_stable()) {\n all_stable_hadrons.push_back(&ptype);\n }\n }\n\n for (const smash::ParticleTypePtr res : all_types_in_the_box_) {\n smash::decaytree::Node tree(res->name(), 1.0, {res}, {res}, {res}, {});\n constexpr double sqrts = 5.0; // This is sufficient to add all possible decays\n smash::decaytree::add_decays(tree, sqrts);\n std::vector fs = tree.final_state_cross_sections();\n smash::deduplicate(fs);\n double wsum = 0.0;\n for (const smash::FinalStateCrossSection &xs : fs) {\n wsum += xs.cross_section_;\n }\n assert(std::abs(wsum - 1.0) < 1.e-9);\n std::cout << res->name() << std::endl;\n for (const smash::FinalStateCrossSection &xs : fs) {\n std::map decay_final_states;\n // For each stable particle count how many of it one finds in the final state\n for (const smash::ParticleTypePtr ptype : all_stable_hadrons) {\n std::string little_str = ptype->name(),\n big_str = xs.name_;\n // How many times little_str occurs in big_str?\n int nPos = big_str.find(little_str, 0);\n int count = 0;\n while (nPos != std::string::npos) {\n count++;\n nPos = big_str.find(little_str, nPos + little_str.size());\n }\n if (count > 0) {\n decay_final_states[ptype] = count;\n }\n }\n all_decay_final_states_[res].emplace_back(\n std::make_pair(xs.cross_section_, decay_final_states));\n std::cout << \" \" << xs.name_ << \" \" << xs.cross_section_ << \"; \";\n for (const auto &hadron_count : decay_final_states) {\n std::cout << hadron_count.second << hadron_count.first->name() << \" \";\n }\n std::cout << std::endl;\n }\n }\n}\n\nstd::ostream& operator<< (std::ostream& out,\n const ScaledVarianceCalculator &svc) {\n out << \"Scaled variance calculator\" << std::endl;\n out << \"T [GeV] = \" << svc.T_\n << \", muB [GeV] = \" << svc.mub_\n << \", muS [GeV] = \" << svc.mus_\n << \", muQ [GeV] = \" << svc.muq_ << std::endl;\n out << \"Quantum statistics = \" << svc.quantum_statistics_ << std::endl;\n out << \"Included conservation laws: \";\n if (svc.energy_conservation_) {\n out << \" energy;\";\n }\n if (svc.B_conservation_) {\n out << \" baryon number;\";\n }\n if (svc.S_conservation_) {\n out << \" strangeness;\";\n }\n if (svc.Q_conservation_) {\n out << \" electric charge;\";\n }\n out << std::endl;\n out << \"Species in the box:\" << std::endl;\n for (const smash::ParticleTypePtr t : svc.all_types_in_the_box_) {\n out << t->name() << \" \";\n }\n out << std::endl;\n return out;\n}\n\n\nint main() {\n load_particle_types();\n\n // Prepare the set of particle species in the box\n std::vector hadrons_in_the_box;\n for (const smash::ParticleType &t : smash::ParticleType::list_all()) {\n if (t.is_hadron() && t.mass() < 2.0) {\n hadrons_in_the_box.push_back(&t);\n }\n }\n std::sort(hadrons_in_the_box.begin(), hadrons_in_the_box.end(),\n [&](smash::ParticleTypePtr ta, smash::ParticleTypePtr tb) {\n return ta->mass() < tb->mass();\n });\n\n const double Temperature = 0.2; // [GeV]\n const double muB = 0.0; // [GeV]\n const double muS = 0.0; // [GeV]\n const double muQ = 0.0; // [GeV]\n const bool E_conservation = true;\n const bool B_conservation = true;\n const bool S_conservation = true;\n const bool Q_conservation = true;\n const bool quantum_statistics = false;\n ScaledVarianceCalculator svc(hadrons_in_the_box,\n Temperature, muB, muS, muQ,\n E_conservation, B_conservation,\n S_conservation, Q_conservation,\n quantum_statistics);\n svc.prepare_decays();\n/*\n const double V = 1762.1897; // [fm^3]\n const double E_tot = 972.4227; // [GeV]\n const double B_tot = 0.0;\n const double S_tot = 0.0;\n const double Q_tot = 0.0;\n svc.setTmu_from_conserved(E_tot, V, B_tot, S_tot, Q_tot);\n std::cout << svc;\n\n // Variance of each specie\n for (const smash::ParticleTypePtr t : hadrons_in_the_box) {\n const auto density_and_variance = svc.scaled_variance(\n [&](const smash::ParticleTypePtr t0) { return t0 == t; });\n std::cout << t->name() << \" \" << density_and_variance.first * V << \" \"\n << density_and_variance.second << std::endl;\n }\n\n // Variance of total number\n const auto density_and_variance = svc.scaled_variance(\n [&](const smash::ParticleTypePtr) { return true; });\n std::cout << \"Ntot \" << density_and_variance.first * V << \" \"\n << density_and_variance.second << std::endl;\n*/\n}\n", "meta": {"hexsha": "0f5ae1fed94bbb8fd27595bf136c28b1b38b715d", "size": 15343, "ext": "cc", "lang": "C++", "max_stars_repo_path": "scaled_variance.cc", "max_stars_repo_name": "doliinychenko/scaled_variance_cons_laws", "max_stars_repo_head_hexsha": "eb032fe3901cf4f3a2f9bdddb017da84654be18f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-07-31T10:36:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-31T10:36:07.000Z", "max_issues_repo_path": "scaled_variance.cc", "max_issues_repo_name": "doliinychenko/scaled_variance_cons_laws", "max_issues_repo_head_hexsha": "eb032fe3901cf4f3a2f9bdddb017da84654be18f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scaled_variance.cc", "max_forks_repo_name": "doliinychenko/scaled_variance_cons_laws", "max_forks_repo_head_hexsha": "eb032fe3901cf4f3a2f9bdddb017da84654be18f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.793764988, "max_line_length": 86, "alphanum_fraction": 0.5911490582, "num_tokens": 4540, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7718434978390747, "lm_q2_score": 0.4532618480153861, "lm_q1q2_score": 0.3498472102091987}} {"text": "/*=========================================================================\n\n Program: Visualization Toolkit\n Module: vtkBoostBrandesCentrality.cxx\n\n Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\n All rights reserved.\n See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\n\n This software is distributed WITHOUT ANY WARRANTY; without even\n the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\n PURPOSE. See the above copyright notice for more information.\n\n=========================================================================*/\n/*-------------------------------------------------------------------------\n Copyright 2008 Sandia Corporation.\n Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,\n the U.S. Government retains certain rights in this software.\n-------------------------------------------------------------------------*/\n#include \"vtkBoostBrandesCentrality.h\"\n\n#include \"vtkCellArray.h\"\n#include \"vtkCellData.h\"\n#include \"vtkMath.h\"\n#include \"vtkInformation.h\"\n#include \"vtkInformationVector.h\"\n#include \"vtkObjectFactory.h\"\n#include \"vtkPointData.h\"\n#include \"vtkFloatArray.h\"\n#include \"vtkDataArray.h\"\n#include \"vtkSmartPointer.h\"\n#include \"vtkStringArray.h\"\n\n#include \"vtkBoostGraphAdapter.h\"\n#include \"vtkDirectedGraph.h\"\n#include \"vtkUndirectedGraph.h\"\n\n#include \n#include \n#include \n\nusing namespace boost;\n\nvtkStandardNewMacro(vtkBoostBrandesCentrality);\n\n//-----------------------------------------------------------------------------\nvtkBoostBrandesCentrality::vtkBoostBrandesCentrality() :\n UseEdgeWeightArray (false),\n InvertEdgeWeightArray (false),\n EdgeWeightArrayName (NULL)\n{\n}\n\n//-----------------------------------------------------------------------------\nvtkBoostBrandesCentrality::~vtkBoostBrandesCentrality()\n{\n this->SetEdgeWeightArrayName(0);\n}\n\n//-----------------------------------------------------------------------------\nvoid vtkBoostBrandesCentrality::PrintSelf(ostream& os, vtkIndent indent)\n{\n this->Superclass::PrintSelf(os, indent);\n\n os << indent << \"UseEdgeWeightArray: \" << this->UseEdgeWeightArray << endl;\n\n os << indent << \"InvertEdgeWeightArray: \" << this->InvertEdgeWeightArray\n << endl;\n\n os << indent << \"this->EdgeWeightArrayName: \" <<\n (this->EdgeWeightArrayName ? this->EdgeWeightArrayName : \"NULL\") << endl;\n}\n\n//-----------------------------------------------------------------------------\nint vtkBoostBrandesCentrality::RequestData(\n vtkInformation *vtkNotUsed(request),\n vtkInformationVector **inputVector,\n vtkInformationVector *outputVector)\n{\n // get the info objects\n vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);\n vtkInformation *outInfo = outputVector->GetInformationObject(0);\n\n // get the input and output\n vtkGraph *input = vtkGraph::SafeDownCast(\n inInfo->Get(vtkDataObject::DATA_OBJECT()));\n vtkGraph *output = vtkGraph::SafeDownCast(\n outInfo->Get(vtkDataObject::DATA_OBJECT()));\n\n // Send the data to output.\n output->ShallowCopy(input);\n\n // Compute betweenness centrality\n\n // Property map for vertices\n vtkFloatArray* vertexCMap = vtkFloatArray::New();\n vertexCMap->SetName(\"centrality\");\n identity_property_map imap;\n\n // Property map for edges\n vtkFloatArray* edgeCMap = vtkFloatArray::New();\n edgeCMap->SetName(\"centrality\");\n vtkGraphEdgePropertyMapHelper helper(edgeCMap);\n\n vtkSmartPointer edgeWeight (0);\n if(this->UseEdgeWeightArray && this->EdgeWeightArrayName)\n {\n if(!this->InvertEdgeWeightArray)\n {\n edgeWeight = input->GetEdgeData()->GetArray(this->EdgeWeightArrayName);\n }\n else\n {\n vtkDataArray* weights =\n input->GetEdgeData()->GetArray(this->EdgeWeightArrayName);\n\n if(!weights)\n {\n vtkErrorMacro(<<\"Error: Edge weight array \" << this->EdgeWeightArrayName\n << \" is set but not found or not a data array.\\n\");\n return 0;\n }\n\n edgeWeight.TakeReference(\n vtkDataArray::CreateDataArray(weights->GetDataType()));\n\n double range[2];\n weights->GetRange(range);\n\n if(weights->GetNumberOfComponents() > 1)\n {\n return 0;\n }\n\n for(int i=0; i < weights->GetDataSize(); ++i)\n {\n edgeWeight->InsertNextTuple1(range[1] - weights->GetTuple1(i));\n }\n }\n\n if(!edgeWeight)\n {\n vtkErrorMacro(<<\"Error: Edge weight array \" << this->EdgeWeightArrayName\n << \" is set but not found or not a data array.\\n\");\n return 0;\n }\n }\n\n // Is the graph directed or undirected\n if (vtkDirectedGraph::SafeDownCast(output))\n {\n vtkDirectedGraph *g = vtkDirectedGraph::SafeDownCast(output);\n if(edgeWeight)\n {\n vtkGraphEdgePropertyMapHelper helper2(edgeWeight);\n brandes_betweenness_centrality(g,\n centrality_map(vertexCMap).edge_centrality_map(\n helper).vertex_index_map(imap).weight_map(helper2));\n }\n else\n {\n brandes_betweenness_centrality(g,\n centrality_map(vertexCMap).edge_centrality_map(\n helper).vertex_index_map(imap));\n }\n }\n else\n {\n vtkUndirectedGraph *g = vtkUndirectedGraph::SafeDownCast(output);\n if(edgeWeight)\n {\n vtkGraphEdgePropertyMapHelper helper2(edgeWeight);\n brandes_betweenness_centrality(g,\n centrality_map(vertexCMap).edge_centrality_map(\n helper).vertex_index_map(imap).weight_map(helper2));\n }\n else\n {\n brandes_betweenness_centrality(g,\n centrality_map(vertexCMap).edge_centrality_map(\n helper).vertex_index_map(imap));\n }\n }\n\n // Add the arrays to the output and dereference\n output->GetVertexData()->AddArray(vertexCMap);\n vertexCMap->Delete();\n output->GetEdgeData()->AddArray(edgeCMap);\n edgeCMap->Delete();\n\n return 1;\n}\n", "meta": {"hexsha": "78bcfee3d0a230474ee2773ae419310fd05cc5fa", "size": 5994, "ext": "cxx", "lang": "C++", "max_stars_repo_path": "Infovis/BoostGraphAlgorithms/vtkBoostBrandesCentrality.cxx", "max_stars_repo_name": "inviCRO/VTK", "max_stars_repo_head_hexsha": "a2dc2e79d4ecb8f6da900535b32e1a2a702c7f48", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-12-02T07:23:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-02T07:23:36.000Z", "max_issues_repo_path": "Infovis/BoostGraphAlgorithms/vtkBoostBrandesCentrality.cxx", "max_issues_repo_name": "inviCRO/VTK", "max_issues_repo_head_hexsha": "a2dc2e79d4ecb8f6da900535b32e1a2a702c7f48", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 14.0, "max_issues_repo_issues_event_min_datetime": "2015-04-25T17:54:13.000Z", "max_issues_repo_issues_event_max_datetime": "2017-01-13T15:30:39.000Z", "max_forks_repo_path": "Infovis/BoostGraphAlgorithms/vtkBoostBrandesCentrality.cxx", "max_forks_repo_name": "inviCRO/VTK", "max_forks_repo_head_hexsha": "a2dc2e79d4ecb8f6da900535b32e1a2a702c7f48", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-03-13T17:21:31.000Z", "max_forks_repo_forks_event_max_datetime": "2015-03-13T17:21:31.000Z", "avg_line_length": 31.0569948187, "max_line_length": 80, "alphanum_fraction": 0.6301301301, "num_tokens": 1382, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7461389817407016, "lm_q2_score": 0.46879062662624377, "lm_q1q2_score": 0.3497829608004909}} {"text": "/**\n * Copyright (c) 2017 Melown Technologies SE\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n/*\n * color.cpp\n */\n\n#include \"color.hpp\"\n\n#include \n#include \n\n\nnamespace imgproc {\n\n/* class RGBColor */\n\nRGBColor::RGBColor( float r, float g, float b )\n : ublas::vector(3) {\n (*this)(0) = r; (*this)(1) = g; (*this)(2) = b;\n}\n\nRGBColor::RGBColor( const ublas::vector & c )\n : ublas::vector( c ) {}\n\nRGBColor::RGBColor( const YCCColor & c )\n : ublas::vector(3) {\n\n //assert( c(0) <= 1.0 && c(0) >= 0.0 );\n\n ublas::matrix a( 3, 3 );\n a( 0, 0 ) = 1.f; a( 0, 1 ) = 9.2674E-4f; a( 0, 2 ) = 1.4017f;\n a( 1, 0 ) = 1.f; a( 1, 1 ) = -0.34370f; a( 1, 2 ) = -0.7142f;\n a( 2, 0 ) = 1.f; a( 2, 1 ) = 1.7722f; a( 2, 2 ) = 9.9022E-4f;\n\n *this = RGBColor( ublas::prod( a, c ) );\n\n // clip to fit into rgb gamut\n ublas::vector yccnochroma( 3 );\n yccnochroma(0) = c(0); yccnochroma(1) = yccnochroma(2) = 0.f;\n ublas::vector nochroma = ublas::prod( a, yccnochroma );\n\n if ( (*this)(0) < 0.f ) {\n ublas::vector diff = *this - nochroma;\n float u = ( 0.f - nochroma(0) ) / ( (*this)(0) - nochroma(0) );\n *this = RGBColor( nochroma + u * diff );\n }\n\n if ( (*this)(0) > 1.f ) {\n ublas::vector diff = *this - nochroma;\n float u = ( 1.f - nochroma(0) ) / ( (*this)(0) - nochroma(0) );\n *this = RGBColor( nochroma + u * diff );\n }\n\n if ( (*this)(1) < 0.f ) {\n ublas::vector diff = *this - nochroma;\n float u = ( 0.f - nochroma(1) ) / ( (*this)(1) - nochroma(1) );\n *this = RGBColor( nochroma + u * diff );\n }\n\n if ( (*this)(1) > 1.f ) {\n ublas::vector diff = *this - nochroma;\n float u = ( 1.f - nochroma(1) ) / ( (*this)(1) - nochroma(1) );\n *this = RGBColor( nochroma + u * diff );\n }\n\n if ( (*this)(2) < 0.f ) {\n ublas::vector diff = *this - nochroma;\n float u = ( 0.f - nochroma(2) ) / ( (*this)(2) - nochroma(2) );\n *this = RGBColor( nochroma + u * diff );\n }\n\n if ( (*this)(2) > 1.f ) {\n ublas::vector diff = *this - nochroma;\n float u = ( 1.f - nochroma(2) ) / ( (*this)(2) - nochroma(2) );\n *this = RGBColor( nochroma + u * diff );\n }\n}\n\n\ngil::rgb8_pixel_t RGBColor::rgbpixel() const {\n\n return gil::rgb8_pixel_t(\n (unsigned char)(round( 0xff * (*this)(0) )),\n (unsigned char)(round( 0xff * (*this)(1) )),\n (unsigned char)(round( 0xff * (*this)(2) )));\n}\n\nRGBColor::RGBColor( const gil::rgb8_pixel_t & p )\n : ublas::vector(3) {\n\n (*this)(0) = (float) p[0] / 0xff;\n (*this)(1) = (float) p[1] / 0xff;\n (*this)(2) = (float) p[2] / 0xff;\n}\n\n/* class YCCColor */\n\nYCCColor::YCCColor( float y, float cb, float cr )\n : ublas::vector(3) {\n (*this)(0) = y; (*this)(1) = cb; (*this)(2) = cr;\n}\n\nYCCColor::YCCColor( const ublas::vector & c )\n : ublas::vector( c ) {}\n\nYCCColor::YCCColor( const RGBColor & c )\n : ublas::vector(3) {\n\n /*assert( c(0) <= 1.0 && c(0) >= 0.0 );\n assert( c(1) <= 1.0 && c(1) >= 0.0 );\n assert( c(2) <= 1.0 && c(2) >= 0.0 );*/\n\n ublas::matrix a( 3, 3 );\n a( 0, 0 ) = 0.299f; a( 0, 1 ) = 0.587f; a( 0, 2 ) = 0.114f;\n a( 1, 0 ) = -0.169f; a( 1, 1 ) = -0.331f; a( 1, 2 ) = 0.500f;\n a( 2, 0 ) = 0.500f; a( 2, 1 ) = -0.419f; a( 2, 2 ) = -0.081f;\n\n //std::cout << ublas::prod( a, c );\n\n *this = YCCColor( ublas::prod( a, c ) );\n\n //std::cout << \" =? \" << *this << std::endl;\n}\n\nYCCColor::YCCColor( const gil::rgb8_pixel_t & yccpixel )\n : ublas::vector(3) {\n\n (*this)(0) = ( (float) yccpixel[0] / 0xff ) - 0.5f;\n (*this)(1) = ( (float) yccpixel[1] / 0xff ) - 0.5f;\n (*this)(2) = ( (float) yccpixel[2] / 0xff ) - 0.5f;\n}\n\nYCCColor::YCCColor( const gil::rgb32f_pixel_t & yccpixel )\n : ublas::vector(3) {\n\n (*this)(0) = ( yccpixel[0] / 0xff ) - 0.5f;\n (*this)(1) = ( yccpixel[1] / 0xff ) - 0.5f;\n (*this)(2) = ( yccpixel[2] / 0xff ) - 0.5f;\n}\n\n\ngil::rgb8_pixel_t YCCColor::yccpixel() const {\n\n return gil::rgb8_pixel_t(\n (int) round( 0xff * (*this)(0) ),\n (int) round( 0xff * ( (*this)(1) + 0.5f ) ),\n (int) round( 0xff * ( (*this)(2) + 0.5f ) ) );\n}\n\nfloat ccDiff( const YCCColor & color1, const YCCColor & color2 ) {\n\n float hue1, hue2;\n\n hue1 = atan2( color1( 2 ), color1( 1 ) );\n\n hue2 = atan2( color2( 2 ), color2( 1 ) );\n\n return std::min( fabs( hue1 - hue2 ), float(2 * M_PI) - fabs( hue1 - hue2 ) );\n\n //return sqr( color2( 1 ) - color1( 1 ) ) + sqr( color2( 2 ) - color1( 2 ) );\n}\n\n} // namespace imgproc \n", "meta": {"hexsha": "e50e1756eb4b1ff82a03bc2636327efe4d1ecd1d", "size": 5998, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "imgproc/color.cpp", "max_stars_repo_name": "melowntech/libimgproc", "max_stars_repo_head_hexsha": "2dc035d12b0d0128f0f97274d2efa62de924b257", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2017-06-23T19:16:00.000Z", "max_stars_repo_stars_event_max_datetime": "2019-03-11T08:10:56.000Z", "max_issues_repo_path": "externals/browser/externals/browser/externals/libimgproc/imgproc/color.cpp", "max_issues_repo_name": "HanochZhu/vts-browser-unity-plugin", "max_issues_repo_head_hexsha": "32a22d41e21b95fb015326f95e401d87756d0374", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "externals/browser/externals/browser/externals/libimgproc/imgproc/color.cpp", "max_forks_repo_name": "HanochZhu/vts-browser-unity-plugin", "max_forks_repo_head_hexsha": "32a22d41e21b95fb015326f95e401d87756d0374", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-09-25T05:22:31.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-25T05:22:31.000Z", "avg_line_length": 32.0748663102, "max_line_length": 82, "alphanum_fraction": 0.5608536179, "num_tokens": 2163, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7279754489059774, "lm_q2_score": 0.480478678047907, "lm_q1q2_score": 0.3497766813416757}} {"text": "// Copyright (C) 2015 The Regents of the University of California (Regents).\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions are\n// met:\n//\n// * Redistributions of source code must retain the above copyright\n// notice, this list of conditions and the following disclaimer.\n//\n// * Redistributions in binary form must reproduce the above\n// copyright notice, this list of conditions and the following\n// disclaimer in the documentation and/or other materials provided\n// with the distribution.\n//\n// * Neither the name of The Regents or University of California nor the\n// names of its contributors may be used to endorse or promote products\n// derived from this software without specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE\n// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n// POSSIBILITY OF SUCH DAMAGE.\n//\n// Please contact the author of this library if you have any questions.\n// Author: Chris Sweeney (cmsweeney@cs.ucsb.edu)\n\n#include \"theia/sfm/global_pose_estimation/least_unsquared_deviation_position_estimator.h\"\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"theia/math/qp_solver.h\"\n#include \"theia/sfm/global_pose_estimation/pairwise_translation_and_scale_error.h\"\n#include \"theia/sfm/types.h\"\n#include \"theia/util/map_util.h\"\n#include \"theia/util/util.h\"\n\nnamespace theia {\nnamespace {\n\nusing Eigen::Matrix3d;\nusing Eigen::Vector3d;\n\nVector3d GetRotatedTranslation(const Vector3d& rotation_angle_axis,\n const Vector3d& translation) {\n Matrix3d rotation;\n ceres::AngleAxisToRotationMatrix(\n rotation_angle_axis.data(),\n ceres::ColumnMajorAdapter3x3(rotation.data()));\n return rotation.transpose() * translation;\n}\n\n} // namespace\n\nLeastUnsquaredDeviationPositionEstimator::\n LeastUnsquaredDeviationPositionEstimator(\n const LeastUnsquaredDeviationPositionEstimator::Options& options)\n : options_(options) {\n CHECK_GT(options_.max_num_iterations, 0);\n CHECK_GT(options_.max_num_reweighted_iterations, 0);\n}\n\nbool LeastUnsquaredDeviationPositionEstimator::EstimatePositions(\n const std::unordered_map& view_pairs,\n const std::unordered_map& orientations,\n std::unordered_map* positions) {\n CHECK_NOTNULL(positions)->clear();\n\n InitializeIndexMapping(view_pairs, orientations);\n\n // Set up the linear system.\n SetupConstraintMatrix(view_pairs, orientations);\n solution_.setZero(constraint_matrix_.cols());\n weights_.setConstant(constraint_matrix_.rows(), 1.0);\n\n // Set the lower bounds for the QP. The positions should be unbounded while\n // the scales havea lower bound of 1.0.\n Eigen::VectorXd lower_bound(constraint_matrix_.cols());\n lower_bound.head(3 * orientations.size())\n .setConstant(-std::numeric_limits::infinity());\n lower_bound.tail(view_pairs.size()).setConstant(1.0);\n\n // Solve for the camera positions using an IRLS scheme. The values p and r are\n // constant at zero.\n Eigen::SparseMatrix P(constraint_matrix_.rows(),\n constraint_matrix_.rows());\n Eigen::VectorXd q(constraint_matrix_.cols());\n q.setZero();\n const double r = 0;\n QPSolver::Options qp_solver_options;\n qp_solver_options.max_num_iterations = 10;\n for (int i = 0; i < options_.max_num_reweighted_iterations; i++) {\n if (i > 0) {\n UpdateConstraintWeights();\n }\n\n // Compute P = A^t * W * A, the quadratic matrix term for our QP.\n P = constraint_matrix_.transpose() * weights_.matrix().asDiagonal() *\n constraint_matrix_;\n\n // Solve the quadratic program. Increase the number of possible iterations\n // each time.\n qp_solver_options.max_num_iterations = std::min(\n options_.max_num_iterations, 2 * qp_solver_options.max_num_iterations);\n QPSolver qp_solver(qp_solver_options, P, q, r);\n const Eigen::VectorXd prev_solution = solution_;\n qp_solver.SetLowerBound(lower_bound);\n if (!qp_solver.Solve(&solution_)) {\n LOG(WARNING) << \"Could not solve the Quadratic Program for the least \"\n \"unsquared deviations position solver.\";\n return false;\n }\n }\n\n // Set the estimated positions.\n for (const auto& view_id_index : view_id_to_index_) {\n const int index = view_id_index.second;\n const ViewId view_id = view_id_index.first;\n if (index == kConstantViewIndex) {\n (*positions)[view_id] = Eigen::Vector3d::Zero();\n } else {\n (*positions)[view_id] = solution_.segment<3>(index);\n }\n }\n\n return true;\n}\n\nvoid LeastUnsquaredDeviationPositionEstimator::InitializeIndexMapping(\n const std::unordered_map& view_pairs,\n const std::unordered_map& orientations) {\n std::unordered_set views;\n for (const auto& view_pair : view_pairs) {\n if (ContainsKey(orientations, view_pair.first.first)) {\n views.insert(view_pair.first.first);\n }\n if (ContainsKey(orientations, view_pair.first.second)) {\n views.insert(view_pair.first.second);\n }\n }\n\n // Create a mapping from the view id to the index of the linear system.\n int index = kConstantViewIndex;\n view_id_to_index_.reserve(orientations.size());\n for (const ViewId view_id : views) {\n view_id_to_index_[view_id] = index;\n index += 3;\n }\n\n // Create a mapping from the view id pair to the index of the linear system.\n view_id_pair_to_index_.reserve(view_pairs.size());\n for (const auto& view_pair : view_pairs) {\n view_id_pair_to_index_[view_pair.first] = index;\n ++index;\n }\n}\n\nvoid LeastUnsquaredDeviationPositionEstimator::SetupConstraintMatrix(\n const std::unordered_map& view_pairs,\n const std::unordered_map& orientations) {\n constraint_matrix_.resize(3 * view_pairs.size(),\n 3 * orientations.size() + view_pairs.size());\n\n // Add the camera to camera constraints.\n std::vector > triplet_list;\n triplet_list.reserve(9 * view_pairs.size());\n int row = 0;\n for (const auto& view_pair : view_pairs) {\n const ViewIdPair view_id_pair = view_pair.first;\n\n const int view1_index = FindOrDie(view_id_to_index_, view_id_pair.first);\n const int view2_index = FindOrDie(view_id_to_index_, view_id_pair.second);\n const int scale_index =\n FindOrDieNoPrint(view_id_pair_to_index_, view_id_pair);\n\n // Rotate the relative translation so that it is aligned to the global\n // orientation frame.\n const Vector3d translation_direction =\n GetRotatedTranslation(FindOrDie(orientations, view_id_pair.first),\n view_pair.second.position_2);\n\n // Add the constraint for view 1 in the minimization:\n // position2 - position1 - scale_1_2 * translation_direction.\n if (view1_index != kConstantViewIndex) {\n triplet_list.emplace_back(row + 0, view1_index + 0, -1.0);\n triplet_list.emplace_back(row + 1, view1_index + 1, -1.0);\n triplet_list.emplace_back(row + 2, view1_index + 2, -1.0);\n }\n\n // Add the constraint for view 2 in the minimization:\n // position2 - position1 - scale_1_2 * translation_direction.\n if (view2_index != kConstantViewIndex) {\n triplet_list.emplace_back(row + 0, view2_index + 0, 1.0);\n triplet_list.emplace_back(row + 1, view2_index + 1, 1.0);\n triplet_list.emplace_back(row + 2, view2_index + 2, 1.0);\n }\n\n // Add the constraint for scale in the minimization:\n // position2 - position1 - scale_1_2 * translation_direction.\n triplet_list.emplace_back(row + 0, scale_index, -translation_direction[0]);\n triplet_list.emplace_back(row + 1, scale_index, -translation_direction[1]);\n triplet_list.emplace_back(row + 2, scale_index, -translation_direction[2]);\n\n row += 3;\n }\n\n constraint_matrix_.setFromTriplets(triplet_list.begin(), triplet_list.end());\n\n VLOG(2) << view_pairs.size() << \" camera to camera constraints were added \"\n \"to the position estimation problem.\";\n}\n\n// Compute the error:\n// err_i_j = || c_j - c_i - scale_i_j * t_i_j ||^2\n//\n// For each pairwise constraint, set w_i_j = (err_i_j + delta)^(-1/2) to\n// reweight the QP solver for robustness.\nvoid LeastUnsquaredDeviationPositionEstimator::UpdateConstraintWeights() {\n static const double delta = 1e-12;\n // Compute the errors with a simple matrix multiplication.\n const Eigen::VectorXd errors = constraint_matrix_ * solution_;\n weights_ = (errors.array().square() + delta).sqrt().inverse();\n}\n\n} // namespace theia\n", "meta": {"hexsha": "803be5c6e88ca15cebdabf5cff9a010015a33e89", "size": 9493, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/theia/sfm/global_pose_estimation/least_unsquared_deviation_position_estimator.cc", "max_stars_repo_name": "LEON-MING/TheiaSfM_Leon", "max_stars_repo_head_hexsha": "8ac187b80100ad7f52fe9af49fa4a0db6db226b9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2019-01-17T17:37:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-26T09:21:38.000Z", "max_issues_repo_path": "src/theia/sfm/global_pose_estimation/least_unsquared_deviation_position_estimator.cc", "max_issues_repo_name": "LEON-MING/TheiaSfM_Leon", "max_issues_repo_head_hexsha": "8ac187b80100ad7f52fe9af49fa4a0db6db226b9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/theia/sfm/global_pose_estimation/least_unsquared_deviation_position_estimator.cc", "max_forks_repo_name": "LEON-MING/TheiaSfM_Leon", "max_forks_repo_head_hexsha": "8ac187b80100ad7f52fe9af49fa4a0db6db226b9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2019-09-09T03:34:20.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-21T06:00:50.000Z", "avg_line_length": 39.719665272, "max_line_length": 90, "alphanum_fraction": 0.7182134204, "num_tokens": 2271, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.658417487156366, "lm_q2_score": 0.5312093733737563, "lm_q1q2_score": 0.34975754077065646}} {"text": "// Copyright (C) 2015 The Regents of the University of California (Regents).\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions are\n// met:\n//\n// * Redistributions of source code must retain the above copyright\n// notice, this list of conditions and the following disclaimer.\n//\n// * Redistributions in binary form must reproduce the above\n// copyright notice, this list of conditions and the following\n// disclaimer in the documentation and/or other materials provided\n// with the distribution.\n//\n// * Neither the name of The Regents or University of California nor the\n// names of its contributors may be used to endorse or promote products\n// derived from this software without specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE\n// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n// POSSIBILITY OF SUCH DAMAGE.\n//\n// Please contact the author of this library if you have any questions.\n// Author: Chris Sweeney (cmsweeney@cs.ucsb.edu)\n\n#include \"theia/sfm/global_pose_estimation/least_unsquared_deviation_position_estimator.h\"\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"theia/math/constrained_l1_solver.h\"\n#include \"theia/sfm/types.h\"\n#include \"theia/util/map_util.h\"\n#include \"theia/util/util.h\"\n\nnamespace theia {\nnamespace {\n\nusing Eigen::Matrix3d;\nusing Eigen::Vector3d;\n\nVector3d GetRotatedTranslation(const Vector3d& rotation_angle_axis,\n const Vector3d& translation) {\n Matrix3d rotation;\n ceres::AngleAxisToRotationMatrix(\n rotation_angle_axis.data(),\n ceres::ColumnMajorAdapter3x3(rotation.data()));\n return rotation.transpose() * translation;\n}\n\n} // namespace\n\nLeastUnsquaredDeviationPositionEstimator::\n LeastUnsquaredDeviationPositionEstimator(\n const LeastUnsquaredDeviationPositionEstimator::Options& options)\n : options_(options) {\n CHECK_GT(options_.max_num_iterations, 0);\n CHECK_GT(options_.max_num_reweighted_iterations, 0);\n}\n\nbool LeastUnsquaredDeviationPositionEstimator::EstimatePositions(\n const std::unordered_map& view_pairs,\n const std::unordered_map& orientations,\n std::unordered_map* positions) {\n CHECK_NOTNULL(positions)->clear();\n\n InitializeIndexMapping(view_pairs, orientations);\n const int num_views = view_id_to_index_.size();\n const int num_view_pairs = view_id_pair_to_index_.size();\n\n // Set up the linear system.\n SetupConstraintMatrix(view_pairs, orientations);\n Eigen::VectorXd solution;\n solution.setZero(constraint_matrix_.cols());\n\n // Create the lower bound constraint enforcing that all scales are > 1.\n Eigen::SparseMatrix geq_mat(num_view_pairs,\n constraint_matrix_.cols());\n for (int i = 0; i < num_view_pairs; i++) {\n geq_mat.insert(i, 3 * (num_views - 1) + i) = 1.0;\n }\n Eigen::VectorXd geq_vec(num_view_pairs);\n geq_vec.setConstant(1.0);\n\n Eigen::VectorXd b(constraint_matrix_.rows());\n b.setZero();\n\n // Solve for camera positions by solving a constrained L1 problem to enforce\n // all relative translations scales > 1.\n ConstrainedL1Solver::Options l1_options;\n ConstrainedL1Solver solver(\n l1_options, constraint_matrix_, b, geq_mat, geq_vec);\n solver.Solve(&solution);\n\n // Set the estimated positions.\n for (const auto& view_id_index : view_id_to_index_) {\n const int index = view_id_index.second;\n const ViewId view_id = view_id_index.first;\n if (index == kConstantViewIndex) {\n (*positions)[view_id] = Eigen::Vector3d::Zero();\n } else {\n (*positions)[view_id] = solution.segment<3>(index);\n }\n }\n\n return true;\n}\n\nvoid LeastUnsquaredDeviationPositionEstimator::InitializeIndexMapping(\n const std::unordered_map& view_pairs,\n const std::unordered_map& orientations) {\n std::unordered_set views;\n for (const auto& view_pair : view_pairs) {\n if (ContainsKey(orientations, view_pair.first.first) &&\n ContainsKey(orientations, view_pair.first.second)) {\n views.insert(view_pair.first.first);\n views.insert(view_pair.first.second);\n }\n }\n\n // Create a mapping from the view id to the index of the linear system.\n int index = kConstantViewIndex;\n view_id_to_index_.reserve(views.size());\n for (const ViewId view_id : views) {\n view_id_to_index_[view_id] = index;\n index += 3;\n }\n\n // Create a mapping from the view id pair to the index of the linear system.\n view_id_pair_to_index_.reserve(view_pairs.size());\n for (const auto& view_pair : view_pairs) {\n if (ContainsKey(view_id_to_index_, view_pair.first.first) &&\n ContainsKey(view_id_to_index_, view_pair.first.second)) {\n view_id_pair_to_index_[view_pair.first] = index;\n ++index;\n }\n }\n}\n\nvoid LeastUnsquaredDeviationPositionEstimator::SetupConstraintMatrix(\n const std::unordered_map& view_pairs,\n const std::unordered_map& orientations) {\n constraint_matrix_.resize(\n 3 * view_id_pair_to_index_.size(),\n 3 * (view_id_to_index_.size() - 1) + view_pairs.size());\n\n // Add the camera to camera constraints.\n std::vector > triplet_list;\n triplet_list.reserve(9 * view_pairs.size());\n int row = 0;\n for (const auto& view_pair : view_pairs) {\n const ViewIdPair view_id_pair = view_pair.first;\n if (!ContainsKey(view_id_to_index_, view_id_pair.first) ||\n !ContainsKey(view_id_to_index_, view_id_pair.second)) {\n continue;\n }\n\n const int view1_index = FindOrDie(view_id_to_index_, view_id_pair.first);\n const int view2_index = FindOrDie(view_id_to_index_, view_id_pair.second);\n const int scale_index =\n FindOrDieNoPrint(view_id_pair_to_index_, view_id_pair);\n\n // Rotate the relative translation so that it is aligned to the global\n // orientation frame.\n const Vector3d translation_direction =\n GetRotatedTranslation(FindOrDie(orientations, view_id_pair.first),\n view_pair.second.position_2);\n\n // Add the constraint for view 1 in the minimization:\n // position2 - position1 - scale_1_2 * translation_direction.\n if (view1_index != kConstantViewIndex) {\n triplet_list.emplace_back(row + 0, view1_index + 0, -1.0);\n triplet_list.emplace_back(row + 1, view1_index + 1, -1.0);\n triplet_list.emplace_back(row + 2, view1_index + 2, -1.0);\n }\n\n // Add the constraint for view 2 in the minimization:\n // position2 - position1 - scale_1_2 * translation_direction.\n if (view2_index != kConstantViewIndex) {\n triplet_list.emplace_back(row + 0, view2_index + 0, 1.0);\n triplet_list.emplace_back(row + 1, view2_index + 1, 1.0);\n triplet_list.emplace_back(row + 2, view2_index + 2, 1.0);\n }\n\n // Add the constraint for scale in the minimization:\n // position2 - position1 - scale_1_2 * translation_direction.\n triplet_list.emplace_back(row + 0, scale_index, -translation_direction[0]);\n triplet_list.emplace_back(row + 1, scale_index, -translation_direction[1]);\n triplet_list.emplace_back(row + 2, scale_index, -translation_direction[2]);\n\n row += 3;\n }\n\n constraint_matrix_.setFromTriplets(triplet_list.begin(), triplet_list.end());\n\n VLOG(2) << view_pairs.size() << \" camera to camera constraints were added \"\n \"to the position estimation problem.\";\n}\n\nstd::unordered_map LeastUnsquaredDeviationPositionEstimator::EstimatePositionsWrapper(\n const std::unordered_map& view_pairs,\n const std::unordered_map& orientation) {\n std::unordered_map positions;\n EstimatePositions(view_pairs, orientation, &positions);\n return positions;\n}\n\n} // namespace theia\n", "meta": {"hexsha": "d177c76fb596b2023b4edea88e962f3f0509ca2c", "size": 8771, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/theia/sfm/global_pose_estimation/least_unsquared_deviation_position_estimator.cc", "max_stars_repo_name": "Sergej91/TheiaSfM", "max_stars_repo_head_hexsha": "e603e16888456c3e565a2c197fa9f8643c176175", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/theia/sfm/global_pose_estimation/least_unsquared_deviation_position_estimator.cc", "max_issues_repo_name": "Sergej91/TheiaSfM", "max_issues_repo_head_hexsha": "e603e16888456c3e565a2c197fa9f8643c176175", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/theia/sfm/global_pose_estimation/least_unsquared_deviation_position_estimator.cc", "max_forks_repo_name": "Sergej91/TheiaSfM", "max_forks_repo_head_hexsha": "e603e16888456c3e565a2c197fa9f8643c176175", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.331838565, "max_line_length": 111, "alphanum_fraction": 0.724660814, "num_tokens": 2111, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6442251064863697, "lm_q2_score": 0.5428632831725052, "lm_q1q2_score": 0.3497261564093474}} {"text": "/**\nBSD 3-Clause License\n\nThis file is part of the code accompanying the paper\nFrom Planes to Corners: Multi-Purpose Primitive Detection in Unorganized 3D Point Clouds\nby C. Sommer, Y. Sun, L. Guibas, D. Cremers and T. Birdal,\naccepted for Publication in IEEE Robotics and Automation Letters (RA-L) 2020.\n\nCopyright (c) 2019, Christiane Sommer.\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n* Neither the name of the copyright holder nor the names of its\n contributors may be used to endorse or promote products derived from\n this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n// includes\n#include \n#include \n#include \"definitions.h\"\n// libraries\n#include \n#include \n#include \n#include \n// classes\n#include \"Timer.h\"\n#include \"Plane.h\"\n#include \"graph/PlaneGraph.h\"\n#include \"graph/ParallelPlaneGraph.h\"\n#include \"PPF/PairDetector.h\"\n#include \"corners/Corner.h\"\n// function includes\n#include \"io/load_ply_cloud.h\"\n#include \"visualize/pcshow.h\"\n\n/*\n * main\n */\nint main(int argc, char** argv) {\n\n Timer T;\n \n // parse setttings from command line\n std::string ply_file;\n int min_votes = 5;\n double d_min = .1, d_max = 1.;\n int sampling = 50;\n\n CLI::App app{\"Detect and refine orthogonal plane configurations\"};\n app.add_option(\"--img\", ply_file, \"ply file path, from data/\")->required();\n app.add_option(\"--min-votes\", min_votes, \"minimal number of votes to accept configuration\");\n app.add_option(\"--dmin\", d_min, \"minimal distance between two points\");\n app.add_option(\"--dmax\", d_max, \"maximal distance between two points\");\n app.add_option(\"--sampling\", sampling, \"sampling of points\");\n\n try {\n app.parse(argc, argv);\n } catch (const CLI::ParseError& e) {\n return app.exit(e);\n }\n \n // load data\n std::string filepath = \"../data/\";\n std::vector points;\n std::vector normals;\n \n T.tic();\n read_ply_file(filepath+ply_file, points, normals);\n T.toc(\"read data\");\n std::cout << points.size() << \" points loaded.\" << std::endl;\n std::cout << normals.size() << \" normals loaded.\" << std::endl;\n \n pcshow(points);\n \n // pairing\n ppf::PairDetector pairDet(d_max, d_min, min_votes);\n PlaneGraph planeMap(pairDet.para_thresh(), pairDet.distance_bin());\n T.tic();\n pairDet.detect_ortho_pairs(points, normals, planeMap);\n T.toc(\"time pairing PPF \");\n planeMap.print_info();\n \n std::cout << std::endl << \"Thresholds:\\tAngle:\\t\" << pairDet.para_thresh() << \"\\tDistance:\\t\" << pairDet.distance_bin() << std::endl << std::endl;\n\n // clustering & filtering\n T.tic();\n planeMap.cluster_graph_vertices();\n T.toc(\"clustering planes\");\n planeMap.print_info();\n planeMap.print_parameters();\n planeMap.print_edges();\n \n // reduce graph to ParallelPlaneGraph\n T.tic();\n ParallelPlaneGraph redMap = planeMap.reduce_graph();\n T.toc(\"graph reduction\");\n redMap.print_info();\n redMap.print_edges();\n T.tic();\n redMap.triangle_reduce();\n T.toc(\"triangle reduction\");\n redMap.print_info();\n redMap.print_parameters();\n redMap.print_edges();\n \n T.tic();\n redMap.filter_outliers(points, normals, pairDet.distance_bin(), .5*sampling);\n T.toc(\"outlier filtering\");\n redMap.print_info();\n redMap.print_parameters();\n redMap.print_edges();\n \n // coarse refinement\n double lambda = .01 * points.size();\n T.tic();\n redMap.refine(points, normals, lambda, pairDet.distance_bin(), sampling);\n redMap.cluster_graph_vertices();\n T.toc(\"coarse refine and clustering\");\n redMap.print_info();\n redMap.print_parameters();\n redMap.print_edges(); \n\n T.tic();\n redMap.filter_outliers(points, normals, pairDet.distance_bin(), .5*sampling);\n T.toc(\"outlier filtering\");\n redMap.print_info();\n redMap.print_parameters();\n redMap.print_edges();\n \n // find triangles\n std::vector::Triangle> triangles;\n T.tic();\n redMap.find_triangles(triangles);\n T.toc(\"find triangles in reduced graph\");\n redMap.print_triangles(triangles);\n // if no triangles found: stop here\n if (triangles.size() < 1) {\n std::cout << \"No corners found, return.\" << std::endl;\n return 0;\n }\n \n // neighborhood search: Kd-Tree \n const PointCloudAdaptor pc2kd(points);\n KDTree index(3, pc2kd, nanoflann::KDTreeSingleIndexAdaptorParams(10)); // arguments: dimensionality, point cloud adaptor, max leafs\n index.buildIndex();\n std::vector corners;\n std::vector indices;\n \n // find good corners\n T.tic();\n for (const auto& t : triangles) {\n Vec3 n1 = redMap.vertices()[t.first].n();\n Vec3 n2 = redMap.vertices()[t.second].n();\n Vec3 n3 = redMap.vertices()[t.third].n();\n for (const auto d1 : redMap.vertices()[t.first].ds()) for (const auto d2 : redMap.vertices()[t.second].ds()) for (const auto d3 : redMap.vertices()[t.third].ds()) {\n indices = Corner::eval_candidate(points, normals, n1, d1, n2, d2, n3, d3, index);\n std::cout << (-d1*n1 - d2*n2 - d3*n3).transpose() << std::endl;\n if (indices.size() > 0) {\n Corner c(n1, d1, n2, d2, n3, d3);\n c.set_indices(indices);\n if (c.refine(points)) { // only accept if refinement converges\n corners.push_back(c);\n }\n }\n }\n }\n T.toc(\"evaluated corner candidates\");\n \n for (const auto& c : corners) {\n std::cout << c << std::endl << std::endl;\n }\n \n pcshow_corners(points, corners);\n \n}\n", "meta": {"hexsha": "71066c48bcbef50ca9ed6aac0efe02fe35d2e700", "size": 6975, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ply_corners/src/main.cpp", "max_stars_repo_name": "OneOneEleven/orthogonal-planes", "max_stars_repo_head_hexsha": "1a0e282897d3852646cdeba37e71999e58906339", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-09-04T15:19:43.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-04T15:19:43.000Z", "max_issues_repo_path": "ply_corners/src/main.cpp", "max_issues_repo_name": "caoccp/orthogonal-planes", "max_issues_repo_head_hexsha": "1a0e282897d3852646cdeba37e71999e58906339", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ply_corners/src/main.cpp", "max_forks_repo_name": "caoccp/orthogonal-planes", "max_forks_repo_head_hexsha": "1a0e282897d3852646cdeba37e71999e58906339", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-03-19T02:43:11.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T02:43:11.000Z", "avg_line_length": 35.2272727273, "max_line_length": 172, "alphanum_fraction": 0.6679569892, "num_tokens": 1725, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6442250928250375, "lm_q2_score": 0.5428632831725052, "lm_q1q2_score": 0.3497261489931118}} {"text": "//=======================================================================\n// Copyright (c) 2013 Piotr Wygocki\n//\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n//=======================================================================\n/**\n * @file knapsack_unbounded.hpp\n * @brief\n * @author Piotr Wygocki\n * @version 1.0\n * @date 2013-09-20\n */\n#ifndef PAAL_KNAPSACK_UNBOUNDED_HPP\n#define PAAL_KNAPSACK_UNBOUNDED_HPP\n\n#include \"paal/dynamic/knapsack/fill_knapsack_dynamic_table.hpp\"\n#include \"paal/dynamic/knapsack/get_bound.hpp\"\n#include \"paal/dynamic/knapsack/knapsack_common.hpp\"\n#include \"paal/greedy/knapsack_unbounded_two_app.hpp\"\n#include \"paal/utils/functors.hpp\"\n#include \"paal/utils/knapsack_utils.hpp\"\n#include \"paal/utils/less_pointees.hpp\"\n#include \"paal/utils/type_functions.hpp\"\n#include \"paal/utils/irange.hpp\"\n\n#include \n#include \n\n#include \n\nnamespace paal {\n\nnamespace detail {\n/**\n * @brief For knapsack dynamic algorithm for given element the table has to be\n * traversed from the lowest to highest element\n */\nstruct knapsack_get_position_range {\n template \n auto operator()(T begin, T end)->decltype(irange(begin, end)) {\n return irange(begin, end);\n }\n};\n\ntemplate \nReturnType knapsack_unbounded_dynamic(\n KnapsackData knap_data,\n GetBestElement getBest, ValuesComparator compareValues) {\n using Value = typename KnapsackData::value;\n using Size = typename KnapsackData::size;\n using ObjectsIter = typename KnapsackData::object_iter;\n using ObjIterWithValueOrNull =\n boost::optional>;\n std::vector objectOnSize(knap_data.get_capacity() + 1);\n\n auto compare = [ = ](const ObjIterWithValueOrNull & left,\n const ObjIterWithValueOrNull & right) {\n return compareValues(left->second, right->second);\n };\n\n auto objectOnSizeBegin = objectOnSize.begin();\n auto objectOnSizeEnd = objectOnSize.end();\n fill_knapsack_dynamic_table(objectOnSizeBegin, objectOnSizeEnd, knap_data.get_objects(), knap_data.get_size(),\n [&](ObjIterWithValueOrNull val, ObjectsIter obj)\n ->ObjIterWithValueOrNull{\n return std::make_pair(obj, val->second + knap_data.get_value(*obj));\n },\n compare, [](ObjIterWithValueOrNull & val) {\n val = std::make_pair(ObjectsIter{}, Value{});\n },\n detail::knapsack_get_position_range());\n\n // getting position of the max value in the objectOnSize array\n auto maxPos = getBest(objectOnSizeBegin, objectOnSizeEnd, compare);\n\n // setting solution\n auto remainingSpaceInKnapsack = maxPos;\n while (remainingSpaceInKnapsack != objectOnSizeBegin) {\n assert(*remainingSpaceInKnapsack);\n auto && obj = *((*remainingSpaceInKnapsack)->first);\n knap_data.out(obj);\n remainingSpaceInKnapsack -= knap_data.get_size(obj);\n }\n\n // returning result\n if (maxPos != objectOnSizeEnd) {\n assert(*maxPos);\n return ReturnType((*maxPos)->second, maxPos - objectOnSizeBegin);\n } else {\n return ReturnType(Value{}, Size{});\n }\n}\n\n/**\n * @brief Solution to the knapsack problem\n *\n * @tparam OutputIterator\n * @param objects given objects\n * @param out the result is returned using output iterator\n * @param size functor that for given object returns its size\n * @param value functor that for given object returns its value\n */\ntemplate \nReturnType knapsack(KnapsackData knap_data,\n unbounded_tag, integral_value_tag, retrieve_solution_tag) {\n using ValueType = typename KnapsackData::value;\n using ObjectsIter = typename KnapsackData::object_iter;\n using TableElementType = boost::optional>;\n\n auto && objects = knap_data.get_objects();\n\n if (boost::empty(objects)) {\n return ReturnType{};\n }\n auto maxSize = get_value_bound(knap_data, unbounded_tag{}, upper_tag{});\n auto ret = knapsack_unbounded_dynamic(\n detail::make_knapsack_data(\n knap_data.get_objects(), maxSize, knap_data.get_value(), knap_data.get_size(), knap_data.get_output_iter()),\n get_max_element_on_value_indexed_collection(\n TableElementType(std::make_pair(ObjectsIter{}, knap_data.get_capacity() + 1))),\n utils::greater{});\n return ReturnType(ret.second, ret.first);\n}\n\n/**\n * @brief Solution to the knapsack problem\n *\n * @tparam OutputIterator\n * @param oBegin given objects\n * @param oEnd\n * @param out the result is returned using output iterator\n * @param size functor that for given object returns its size\n * @param value functor that for given object returns its value\n */\ntemplate \ntypename KnapsackData::return_type\nknapsack(KnapsackData knap_data,\n unbounded_tag, integral_size_tag, retrieve_solution_tag) {\n using Value = typename KnapsackData::value;\n return knapsack_unbounded_dynamic(std::move(knap_data),\n detail::get_max_element_on_capacity_indexed_collection(),\n utils::less{});\n}\n\n} // detail\n\n/**\n * @brief Solution to the knapsack problem\n *\n * @tparam Objects\n * @tparam OutputIterator\n * @tparam ObjectSizeFunctor\n * @tparam ObjectValueFunctor\n * @param oBegin given objects\n * @param oEnd\n * @param out the result is returned using output iterator\n * @param size functor that for given object returns its size\n * @param value functor that for given object returns its value\n */\ntemplate \ntypename detail::knapsack_base::return_type\nknapsack_unbounded(Objects && objects,\n detail::FunctorOnRangePValue\n capacity, // capacity is of size type\n OutputIterator out, ObjectSizeFunctor size,\n ObjectValueFunctor value = ObjectValueFunctor()) {\n return detail::knapsack_check_integrality(detail::make_knapsack_data(std::forward(objects), capacity, size,\n value, out), detail::unbounded_tag{},\n detail::retrieve_solution_tag());\n}\n\n} // paal\n\n#endif // PAAL_KNAPSACK_UNBOUNDED_HPP\n", "meta": {"hexsha": "9597e8c010b37af43f8bb4dcbea6d75959dad0b6", "size": 6921, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/paal/dynamic/knapsack_unbounded.hpp", "max_stars_repo_name": "Kommeren/AA", "max_stars_repo_head_hexsha": "e537b58d50e93d4a72709821b9ea413008970c6b", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/paal/dynamic/knapsack_unbounded.hpp", "max_issues_repo_name": "Kommeren/AA", "max_issues_repo_head_hexsha": "e537b58d50e93d4a72709821b9ea413008970c6b", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/paal/dynamic/knapsack_unbounded.hpp", "max_forks_repo_name": "Kommeren/AA", "max_forks_repo_head_hexsha": "e537b58d50e93d4a72709821b9ea413008970c6b", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-02-24T06:23:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-24T06:23:56.000Z", "avg_line_length": 37.6141304348, "max_line_length": 120, "alphanum_fraction": 0.6848721283, "num_tokens": 1604, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6442250928250375, "lm_q2_score": 0.5428632831725052, "lm_q1q2_score": 0.3497261489931118}} {"text": "/* Siconos is a program dedicated to modeling, simulation and control\n * of non smooth dynamical systems.\n *\n * Copyright 2018 INRIA.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n*/\n\n/*!\\file NE....cpp\n \\brief \\ref EMNE_MULTIBODY - C++ input file, Time-Stepping version - O.B.\n\n A multibody example.\n Direct description of the model.\n Simulation with a Time-Stepping scheme.\n*/\n\n#include \"SiconosKernel.hpp\"\n#include \"KneeJointR.hpp\"\n#include \"PrismaticJointR.hpp\"\n#include \nusing namespace std;\n\n/* Given a position of a point in the Inertial Frame and the configuration vector q of a solid\n * returns a position in the spatial frame.\n */\nvoid fromInertialToSpatialFrame(double *positionInInertialFrame, double *positionInSpatialFrame, SP::SiconosVector q )\n{\ndouble q0 = q->getValue(3);\ndouble q1 = q->getValue(4);\ndouble q2 = q->getValue(5);\ndouble q3 = q->getValue(6);\n\n::boost::math::quaternion quatQ(q0, q1, q2, q3);\n::boost::math::quaternion quatcQ(q0, -q1, -q2, -q3);\n::boost::math::quaternion quatpos(0, positionInInertialFrame[0], positionInInertialFrame[1], positionInInertialFrame[2]);\n::boost::math::quaternion quatBuff;\n\n//perform the rotation\nquatBuff = quatQ * quatpos * quatcQ;\n\npositionInSpatialFrame[0] = quatBuff.R_component_2()+q->getValue(0);\npositionInSpatialFrame[1] = quatBuff.R_component_3()+q->getValue(1);\npositionInSpatialFrame[2] = quatBuff.R_component_4()+q->getValue(2);\n\n}\nvoid tipTrajectories(SP::SiconosVector q, double * traj, double length)\n{\n double positionInInertialFrame[3];\n double positionInSpatialFrame[3];\n // Output the position of the tip of beam1\n positionInInertialFrame[0]=length/2;\n positionInInertialFrame[1]=0.0;\n positionInInertialFrame[2]=0.0;\n \n fromInertialToSpatialFrame(positionInInertialFrame, positionInSpatialFrame, q );\n traj[0] = positionInSpatialFrame[0];\n traj[1] = positionInSpatialFrame[1];\n traj[2] = positionInSpatialFrame[2];\n \n \n // std::cout << \"positionInSpatialFrame[0]\" << positionInSpatialFrame[0]< Model loading ...\" << endl << endl;\n // -- Initial positions and velocities --\n SP::SiconosVector q03(new SiconosVector(qDim));\n SP::SiconosVector v03(new SiconosVector(nDim));\n SP::SimpleMatrix I3(new SimpleMatrix(3, 3));\n v03->zero();\n I3->eye();\n I3->setValue(0, 0, 0.1);\n q03->zero();\n (*q03)(2) = -L1 * sqrt(2.0) - L1 / 2;\n\n double angle = M_PI / 2;\n SiconosVector V1(3);\n V1.zero();\n V1.setValue(0, 0);\n V1.setValue(1, 1);\n V1.setValue(2, 0);\n q03->setValue(3, cos(angle / 2));\n q03->setValue(4, V1.getValue(0)*sin(angle / 2));\n q03->setValue(5, V1.getValue(1)*sin(angle / 2));\n q03->setValue(6, V1.getValue(2)*sin(angle / 2));\n\n SP::NewtonEulerDS bouncingbeam(new NewtonEulerDS(q03, v03, m, I3));\n // -- Set external forces (weight) --\n SP::SiconosVector weight3(new SiconosVector(nDof));\n (*weight3)(2) = -m * g;\n bouncingbeam->setFExtPtr(weight3);\n\n // --------------------\n // --- Interactions ---\n // --------------------\n\n // Interaction with the floor\n double e = 0.9;\n SP::SimpleMatrix H(new SimpleMatrix(1, qDim));\n SP::SiconosVector eR(new SiconosVector(1));\n eR->setValue(0, 2.3);\n H->zero();\n (*H)(0, 2) = 1.0;\n SP::NonSmoothLaw nslaw0(new NewtonImpactNSL(e));\n SP::NewtonEulerR relation0(new NewtonEulerR());\n relation0->setJachq(H);\n relation0->setE(eR);\n cout << \"main jacQH\" << endl;\n relation0->jachq()->display();\n\n\n // Interactions\n // Building the prismatic joint for bouncingbeam\n // input - the first concerned DS : bouncingbeam\n // - an axis in the spatial frame (absolute frame)\n // SP::SimpleMatrix H4(new SimpleMatrix(PrismaticJointR::numberOfConstraints(), qDim));\n // H4->zero();\n\n SP::SiconosVector axe1(new SiconosVector(3));\n axe1->zero();\n axe1->setValue(2, 1);\n SP::PrismaticJointR relation4(new PrismaticJointR(axe1, false, bouncingbeam));\n SP::NonSmoothLaw nslaw4(new EqualityConditionNSL(relation4->numberOfConstraints()));\n\n SP::Interaction inter4(new Interaction(nslaw4, relation4));\n SP::Interaction interFloor(new Interaction(nslaw0, relation0));\n\n // -------------\n // --- Model ---\n // -------------\n SP::NonSmoothDynamicalSystem myModel(new NonSmoothDynamicalSystem(t0, T));\n // add the dynamical system in the non smooth dynamical system\n myModel->insertDynamicalSystem(bouncingbeam);\n // link the interaction and the dynamical system\n\n myModel->link(inter4, bouncingbeam);\n myModel->link(interFloor, bouncingbeam);\n // ------------------\n // --- Simulation ---\n // ------------------\n\n // -- (1) OneStepIntegrators --\n\n SP::MoreauJeanOSI OSI3(new MoreauJeanOSI(theta));\n\n // -- (2) Time discretisation --\n SP::TimeDiscretisation t(new TimeDiscretisation(t0, h));\n\n // -- (3) one step non smooth problem\n SP::OneStepNSProblem osnspb(new MLCP());\n\n // -- (4) Simulation setup with (1) (2) (3)\n SP::TimeStepping s(new TimeStepping(myModel, t, OSI3, osnspb));\n s->setNewtonTolerance(5e-4);\n s->setNewtonMaxIteration(50);\n\n\n // =========================== End of model definition ===========================\n\n // ================================= Computation =================================\n\n // --- Get the values to be plotted ---\n // -> saved in a matrix dataPlot\n unsigned int outputSize = 15 + 7;\n SimpleMatrix dataPlot(N, outputSize);\n SimpleMatrix bouncingbeamPlot(2,3*N);\n\n SP::SiconosVector q3 = bouncingbeam->q();\n SP::SiconosVector y= interFloor->y(0);\n SP::SiconosVector ydot= interFloor->y(1);\n\n // --- Time loop ---\n cout << \"====> Start computation ... \" << endl << endl;\n // ==== Simulation loop - Writing without explicit event handling =====\n int k = 0;\n boost::progress_display show_progress(N);\n\n boost::timer time;\n time.restart();\n SP::SiconosVector yAux(new SiconosVector(3));\n yAux->setValue(0, 1);\n SP::SimpleMatrix Jaux(new SimpleMatrix(3, 3));\n Index dimIndex(2);\n Index startIndex(4);\n fprintf(pFile, \"double T[%d*%d]={\", N + 1, outputSize);\n double beamTipTrajectories[6];\n \n for (k = 0; k < N; k++)\n {\n // solve ...\n s->advanceToEvent();\n\n\n\n // --- Get values to be plotted ---\n dataPlot(k, 0) = s->nextTime();\n \n dataPlot(k, 1) = (*q3)(0);\n dataPlot(k, 2) = (*q3)(1);\n dataPlot(k, 3) = (*q3)(2);\n dataPlot(k, 4) = (*q3)(3);\n dataPlot(k, 5) = (*q3)(4);\n dataPlot(k, 6) = (*q3)(5);\n dataPlot(k, 7) = (*q3)(6);\n\n dataPlot(k, 8) = y->norm2();\n dataPlot(k, 9) = ydot->norm2();\n\n\n\n tipTrajectories(q3,beamTipTrajectories,L3);\n bouncingbeamPlot(0,3*k) = beamTipTrajectories[0];\n bouncingbeamPlot(0,3*k+1) = beamTipTrajectories[1];\n bouncingbeamPlot(0,3*k+2) = beamTipTrajectories[2];\n bouncingbeamPlot(1,3*k) = beamTipTrajectories[3];\n bouncingbeamPlot(1,3*k+1) = beamTipTrajectories[4];\n bouncingbeamPlot(1,3*k+2) = beamTipTrajectories[5];\n \n //printf(\"reaction1:%lf \\n\", interFloor->lambda(1)->getValue(0));\n\n for (unsigned int jj = 0; jj < outputSize; jj++)\n {\n if ((k || jj))\n fprintf(pFile, \",\");\n fprintf(pFile, \"%f\", dataPlot(k, jj));\n }\n fprintf(pFile, \"\\n\");\n s->nextStep();\n ++show_progress;\n }\n fprintf(pFile, \"};\");\n cout << endl << \"End of computation - Number of iterations done: \" << k - 1 << endl;\n cout << \"Computation Time \" << time.elapsed() << endl;\n\n // --- Output files ---\n cout << \"====> Output file writing ...\" << endl;\n ioMatrix::write(\"NE_BouncingBeam.dat\", \"ascii\", dataPlot, \"noDim\");\n ioMatrix::write(\"NE_BouncingBeam_beam.dat\", \"ascii\", bouncingbeamPlot, \"noDim\");\n\n double error=0.0, eps=1e-12;\n if ((error=ioMatrix::compareRefFile(dataPlot, \"NE_BouncingBeam.ref\", eps)) >= 0.0\n && error > eps)\n return 1;\n\n\n fclose(pFile);\n }\n\n catch (SiconosException e)\n {\n cout << e.report() << endl;\n }\n catch (...)\n {\n cout << \"Exception caught in NE_...cpp\" << endl;\n }\n\n}\n", "meta": {"hexsha": "dba64d03fd73b5c2da8652807e6ac9b4094d736e", "size": 10024, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/Mechanics/JointsTests/NE_BouncingBeam.cpp", "max_stars_repo_name": "stpua/siconos", "max_stars_repo_head_hexsha": "01cd4a134746b2b22e6473e7a1d8e5bc892cc2a9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/Mechanics/JointsTests/NE_BouncingBeam.cpp", "max_issues_repo_name": "stpua/siconos", "max_issues_repo_head_hexsha": "01cd4a134746b2b22e6473e7a1d8e5bc892cc2a9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/Mechanics/JointsTests/NE_BouncingBeam.cpp", "max_forks_repo_name": "stpua/siconos", "max_forks_repo_head_hexsha": "01cd4a134746b2b22e6473e7a1d8e5bc892cc2a9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.7215189873, "max_line_length": 132, "alphanum_fraction": 0.6122306464, "num_tokens": 2950, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6442250928250375, "lm_q2_score": 0.5428632831725052, "lm_q1q2_score": 0.3497261489931118}} {"text": "\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"clustered_errors.hpp\"\n#include \"clustered_errors_state.hpp\"\n\nusing namespace madlib::dbal::eigen_integration;\n\nusing std::string;\n\nnamespace madlib {\nnamespace modules {\nnamespace regress {\n\n// ------------------------------------------------------------------------\n\ntypedef ClusteredState IClusteredState;\ntypedef ClusteredState MutableClusteredState;\n\n// ------------------------------------------------------------------------\n\n// function used by linear and logistic transitions\nAnyType __clustered_common_transition (AnyType& args, string regressionType,\n void (*func)(\n MutableClusteredState&,\n const MappedColumnVector&,\n const double& y))\n{\n // Early return because of an exception has been \"thrown\" \n // (actually \"warning\") in the previous invocations\n if (args[0].isNull())\n return Null();\n MutableClusteredState state = args[0].getAs();\n\n if (args[1].isNull() || args[2].isNull()) {\n return args[0];\n }\n\n // Get x as a vector of double\n MappedColumnVector x;\n try{\n // an exception is raised in the backend if args[2] contains nulls\n MappedColumnVector xx = args[2].getAs();\n // x is a const reference, we can only rebind to change its pointer\n x.rebind(xx.memoryHandle(), xx.size());\n } catch (const ArrayWithNullException &e) {\n return args[0];\n }\n\n double y;\n if (regressionType == \"log\") //Logistic regression\n y = args[1].getAs() ? 1. : -1;\n else if(regressionType == \"lin\") // Linear regression\n y = args[1].getAs();\n else if(regressionType == \"mlog\")//Multi-logistic regression\n \ty = args[1].getAs();\n\n // const MappedColumnVector& x = args[2].getAs();\n\n if (!std::isfinite(y)) {\n //throw std::domain_error(\"Dependent variables are not finite.\");\n warning(\"Dependent variables are not finite.\");\n return Null();\n } else if (x.size() > std::numeric_limits::max()) {\n //throw std::domain_error(\"Number of independent variables cannot be \"\n // \"larger than 65535.\");\n warning(\"Number of independent variables cannot be larger than 65535.\");\n return Null();\n }\n\n if (state.numRows == 0) {\n if(regressionType == \"mlog\")\n {\n if (args[4].isNull() || args[5].isNull()) {\n return args[0];\n }\n \tstate.numCategories = static_cast(args[4].getAs());\n \tstate.refCategory = static_cast(args[5].getAs());\n } else {\n \tstate.numCategories = 2;\n \tstate.refCategory = 0;\n }\n\n state.widthOfX = static_cast(x.size() * (state.numCategories-1));\n state.resize();\n\n if(regressionType == \"mlog\") {\n\t MappedMatrix coefMat = args[3].getAs();\n Matrix mat = coefMat;\n mat.transposeInPlace();\n mat.resize(coefMat.size(), 1);\n state.coef = mat;\n } else {\n const MappedColumnVector& coef = args[3].getAs();\n state.coef = coef;\n }\n state.meat_half.setZero();\n }\n\n // dimension check\n if (state.widthOfX != static_cast(x.size() * (state.numCategories-1))) {\n //throw std::runtime_error(\"Inconsistent numbers of independent \"\n // \"variables.\");\n warning(\"Inconsistent numbers of independent variables.\");\n return Null();\n }\n state.numRows++;\n (*func)(state, x, y);\n return state.storage();\n}\n\n// ------------------------------------------------------------------------\n\n// function used by linear and logistic merges\nAnyType __clustered_common_merge (AnyType& args)\n{\n // In case the aggregator should be terminated because\n // an exception has been \"thrown\" in the transition function\n if(args[0].isNull() || args[1].isNull())\n return Null();\n MutableClusteredState state1 = args[0].getAs();\n IClusteredState state2 = args[1].getAs();\n\n if (state1.numRows == 0)\n return state2.storage();\n else if (state2.numRows == 0)\n return state1.storage();\n\n state1.numRows += state2.numRows;\n state1.bread += state2.bread;\n state1.meat_half += state2.meat_half;\n\n return state1.storage();\n}\n\n// ------------------------------------------------------------------------\n\n// function used by linear and logistic finals\nAnyType __clustered_common_final (AnyType& args)\n{\n // In case the aggregator should be terminated because\n // an exception has been \"thrown\" in the transition function\n if (args[0].isNull())\n return Null(); \n IClusteredState state = args[0].getAs();\n if (state.numRows == 0) return Null();\n\n Allocator& allocator = defaultAllocator();\n SymmetricPositiveDefiniteEigenDecomposition decomposition(\n state.bread, EigenvaluesOnly, ComputePseudoInverse);\n\n int k = static_cast(state.widthOfX);\n\n Matrix meat(k, k);\n meat = trans(state.meat_half) * state.meat_half;\n\n MutableNativeColumnVector meatvec;\n MutableNativeColumnVector breadvec;\n meatvec.rebind(allocator.allocateArray(k*k));\n breadvec.rebind(allocator.allocateArray(k*k));\n int count = 0;\n for (int i = 0; i < k; i++)\n for (int j = 0; j < k; j++) {\n meatvec(count) = meat(i,j);\n breadvec(count) = state.bread(i,j);\n count++;\n }\n\n AnyType tuple;\n\n tuple << meatvec << breadvec;\n\n return tuple;\n}\n\n// ------------------------------------------------------------------------\n\n// Compute the stats from coef and errs\nAnyType clustered_compute_stats (AnyType& args,\n void (*func)(\n MutableNativeColumnVector&,\n MutableNativeColumnVector&,\n int, int), bool ismlogr)\n{\n //const MappedColumnVector& coef = args[0].getAs();\n ColumnVector coef;\n if (ismlogr){\n\t MappedMatrix coefMat = args[0].getAs();\n Matrix mat = coefMat;\n mat.transposeInPlace();\n mat.resize(coefMat.size(), 1);\n coef = mat;\n }else{\n coef = args[0].getAs();\n }\n const MappedColumnVector& meatvec = args[1].getAs();\n const MappedColumnVector& breadvec = args[2].getAs();\n int mcluster = args[3].getAs();\n int numRows = args[4].getAs();\n int k = static_cast(coef.size());\n Matrix bread(k,k);\n Matrix meat(k,k);\n int count = 0;\n\n for (int i = 0; i < k; i++)\n for (int j = 0; j < k; j++)\n {\n meat(i,j) = meatvec(count);\n bread(i,j) = breadvec(count);\n count++;\n }\n\n if (mcluster == 1) {\n //throw std::domain_error (\"Clustered variance error: Number of clusters cannot be smaller than 2!\");\n warning(\"Clustered variance error: Number of clusters cannot be smaller than 2!\");\n return Null();\n }\n double dfc = (mcluster / (mcluster - 1.)) * ((numRows - 1.) / (numRows - k));\n\n SymmetricPositiveDefiniteEigenDecomposition decomposition(\n bread, EigenvaluesOnly, ComputePseudoInverse);\n Matrix inverse_of_bread = decomposition.pseudoInverse();\n Matrix cov(k, k);\n cov = inverse_of_bread * meat * inverse_of_bread;\n\n MutableNativeColumnVector errs;\n MutableNativeColumnVector stats;\n MutableNativeColumnVector pValues;\n Allocator& allocator = defaultAllocator();\n\n errs.rebind(allocator.allocateArray(k));\n stats.rebind(allocator.allocateArray(k));\n pValues.rebind(allocator.allocateArray(k));\n for (int i = 0; i < k; i++)\n {\n if (inverse_of_bread(i,i) < 0)\n errs(i) = 0;\n else\n errs(i) = std::sqrt(cov(i,i) * dfc);\n\n if (coef(i) == 0 && errs(i) == 0)\n stats(i) = 0;\n else\n stats(i) = coef(i) / errs(i);\n }\n\n if (numRows > k)\n (*func)(pValues, stats, numRows, k);\n\n AnyType tuple;\n\n\ttuple << coef << errs << stats\n\t\t << (numRows > k\n\t\t\t ? pValues\n\t\t\t : Null());\n return tuple;\n}\n\n// ------------------------------------------------------------------------\n\n// compute t-stats\nvoid __compute_t_stats (MutableNativeColumnVector& pValues,\n MutableNativeColumnVector& stats,\n int numRows, int k)\n{\n for (int i = 0; i < k; i++)\n pValues(i) = 2. * prob::cdf(\n boost::math::complement(\n prob::students_t(static_cast(numRows - k)),\n std::fabs(stats(i))));\n}\n// ------------------------------------------------------------------------\n\n// compute t-stats\nvoid __compute_z_stats (MutableNativeColumnVector& pValues,\n MutableNativeColumnVector& stats,\n int numRows, int k)\n{\n (void)numRows;\n for (int i = 0; i < k; i++)\n pValues(i) = 2. * prob::cdf(\n boost::math::complement(prob::normal(), std::fabs(stats(i))));\n}\n\n// ------------------------------------------------------------------------\n// linear clustered\n// ------------------------------------------------------------------------\n\nvoid __linear_trans_compute (MutableClusteredState& state,\n const MappedColumnVector& x, const double& y)\n{\n // On Redhat, I have to use the next a few lines instead of\n // state.meat_half += (y - trans(state.coef) * x) * x;\n double sm = 0;\n for (int i = 0; i < state.widthOfX; i++) sm += state.coef(i) * x(i);\n sm = y - sm;\n for (int i = 0; i < state.widthOfX; i++)\n state.meat_half(0,i) += sm * x(i);\n\n state.bread += x * trans(x);\n}\n\n// ------------------------------------------------------------------------\n\nAnyType __clustered_err_lin_transition::run (AnyType& args)\n{\n return __clustered_common_transition(args, \"lin\", __linear_trans_compute);\n}\n\n// ------------------------------------------------------------------------\n\nAnyType __clustered_err_lin_merge::run (AnyType& args)\n{\n return __clustered_common_merge(args);\n}\n\n// ------------------------------------------------------------------------\n\nAnyType __clustered_err_lin_final::run (AnyType& args)\n{\n return __clustered_common_final(args);\n}\n\n// ------------------------------------------------------------------------\n\nAnyType clustered_lin_compute_stats::run (AnyType& args)\n{\n return clustered_compute_stats(args, __compute_t_stats, false);\n}\n\n// ------------------------------------------------------------------------\n// Logistic clustered standard errors\n// ------------------------------------------------------------------------\n\ninline double sigma(double x) {\n\treturn 1. / (1. + std::exp(-x));\n}\n\nvoid __logistic_trans_compute (MutableClusteredState& state,\n const MappedColumnVector& x, const double& y)\n{\n double sm = 0;\n for (int i = 0; i < state.widthOfX; i++) sm += state.coef(i) * x(i);\n\n double sgn = y > 0 ? -1 : 1;\n double t1 = sigma(sgn * sm);\n double t2 = sigma(-sgn * sm);\n\n for (int i = 0; i < state.widthOfX; i++)\n state.meat_half(0,i) += t1 * sgn * x(i);\n\n state.bread += (t1 * t2) * (x * trans(x));\n}\n\n// ------------------------------------------------------------------------\n\nAnyType __clustered_err_log_transition::run (AnyType& args)\n{\n return __clustered_common_transition(args, \"log\", __logistic_trans_compute);\n}\n\n// ------------------------------------------------------------------------\n\nAnyType __clustered_err_log_merge::run (AnyType& args)\n{\n return __clustered_common_merge(args);\n}\n\n// ------------------------------------------------------------------------\n\nAnyType __clustered_err_log_final::run (AnyType& args)\n{\n return __clustered_common_final(args);\n}\n\n// ------------------------------------------------------------------------\n\nAnyType clustered_log_compute_stats::run (AnyType& args)\n{\n return clustered_compute_stats(args, __compute_z_stats, false);\n}\n\n\n// ------------------------------------------------------------------------\n// Multi-Logistic clustered standard errors\n// ------------------------------------------------------------------------\n\n\nvoid __mlogistic_trans_compute (MutableClusteredState& state,\n const MappedColumnVector& x, const double& y)\n{\n\tint numCategories = state.numCategories -1;\n\tColumnVector yVec(numCategories);\n yVec.fill(0);\n\n //Pivot around the reference category\n if (y > state.refCategory) {\n yVec((int)y - 1) = 1;\n } else if (y < state.refCategory) {\n yVec((int)y) = 1;\n }\n\n// if ((int)y != 0) {\n // yVec(((int)y) - 1) = 1;\n // }\n\n\t/*\n Compute the parameter vector (the 'pi' vector in the documentation)\n for the data point being processed.\n Casting the coefficients into a matrix makes the calculation simple.\n */\n Matrix coef = state.coef;\n coef.resize(numCategories, state.widthOfX/numCategories);\n\n //Store the intermediate calculations because we'll reuse them in the LLH\n ColumnVector t1 = x; //t1 is vector of size state.widthOfX\n t1 = coef*x;\n /*\n Note: The above 2 lines could have been written as:\n ColumnVector t1 = -coef*x;\n\n but this creates warnings. These warnings are somehow related to the factor\n that x is an immutable type.\n */\n\n ColumnVector t2 = t1.array().exp();\n double t3 = 1 + t2.sum();\n ColumnVector pi = t2/t3;\n //The gradient matrix has numCatergories rows and widthOfX columns\n Matrix grad = -yVec * x.transpose() + pi * x.transpose();\n //We cast the gradient into a vector to make the math easier.\n grad.resize(state.widthOfX, 1);\n for (int i = 0; i < state.widthOfX; i++)\n {\n\t\tstate.meat_half(0,i) += grad(i);\n\t}\n\n\t// Compute the 'a' matrix.\n Matrix a(numCategories,numCategories);\n Matrix piDiag = pi.asDiagonal();\n a = pi * pi.transpose() - piDiag;\n\n //Start the Hessian calculations\n //Matrix X_transp_AX(numCategories * state.widthOfX, numCategories * state.widthOfX);\n \tMatrix X_transp_AX( (int)state.widthOfX, (int)state.widthOfX);\n /*\n Again: The following 3 lines could have been written as\n Matrix XXTrans = x * x.transpose();\n but it creates warnings related to the type of x. Here is an easy fix\n */\n Matrix cv_x = x;\n Matrix XXTrans = trans(cv_x);\n XXTrans = cv_x * XXTrans;\n\n //Eigen doesn't supported outer-products for matrices, so we have to do our own.\n //This operation is also known as a tensor-product.\n for (int i1 = 0; i1 < (state.widthOfX/numCategories); i1++){\n for (int i2 = 0; i2 < (state.widthOfX/numCategories); i2++){\n int rowOffset = numCategories * i1;\n int colOffset = numCategories * i2;\n\n X_transp_AX.block(rowOffset, colOffset, numCategories, numCategories) = XXTrans(i1, i2) * a;\n }\n }\n\n state.bread += -1*X_transp_AX;\n}\n\n// ------------------------------------------------------------------------\n\nAnyType __clustered_err_mlog_transition::run (AnyType& args)\n{\n return __clustered_common_transition(args, \"mlog\", __mlogistic_trans_compute);\n}\n\n// ------------------------------------------------------------------------\n\nAnyType __clustered_err_mlog_merge::run (AnyType& args)\n{\n return __clustered_common_merge(args);\n}\n\n// ------------------------------------------------------------------------\n\nAnyType __clustered_err_mlog_final::run (AnyType& args)\n{\n return __clustered_common_final(args);\n}\n\n// ------------------------------------------------------------------------\n\nAnyType clustered_mlog_compute_stats::run (AnyType& args)\n{\n return clustered_compute_stats(args, __compute_z_stats, true);\n}\n\n}\n}\n}\n", "meta": {"hexsha": "84661bd22b30f23085e52bc00e1693511dda7aff", "size": 16406, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/modules/regress/clustered_errors.cpp", "max_stars_repo_name": "fmcquillan99/apache-madlib", "max_stars_repo_head_hexsha": "e2dea62d1eadc7f662f2d926c71f42332f414ca0", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2018-09-18T07:44:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-14T19:45:18.000Z", "max_issues_repo_path": "src/modules/regress/clustered_errors.cpp", "max_issues_repo_name": "fmcquillan99/apache-madlib", "max_issues_repo_head_hexsha": "e2dea62d1eadc7f662f2d926c71f42332f414ca0", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-09-06T05:50:17.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-06T05:50:17.000Z", "max_forks_repo_path": "src/modules/regress/clustered_errors.cpp", "max_forks_repo_name": "fmcquillan99/apache-madlib", "max_forks_repo_head_hexsha": "e2dea62d1eadc7f662f2d926c71f42332f414ca0", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-09-03T20:50:13.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-03T20:50:13.000Z", "avg_line_length": 32.4871287129, "max_line_length": 109, "alphanum_fraction": 0.5455321224, "num_tokens": 3755, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6992544335934766, "lm_q2_score": 0.5, "lm_q1q2_score": 0.3496272167967383}} {"text": "/***********************************************************************************************************************\n * OpenStudio(R), Copyright (c) 2008-2017, Alliance for Sustainable Energy, LLC. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the\n * following conditions are met:\n *\n * (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following\n * disclaimer.\n *\n * (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the\n * following disclaimer in the documentation and/or other materials provided with the distribution.\n *\n * (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote\n * products derived from this software without specific prior written permission from the respective party.\n *\n * (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative\n * works may not use the \"OpenStudio\" trademark, \"OS\", \"os\", or any other confusingly similar designation without\n * specific prior written permission from Alliance for Sustainable Energy, LLC.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES,\n * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER, THE UNITED STATES GOVERNMENT, OR ANY CONTRIBUTORS BE LIABLE FOR\n * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED\n * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n **********************************************************************************************************************/\n\n#include \"CurveExponentialSkewNormal.hpp\"\n#include \"CurveExponentialSkewNormal_Impl.hpp\"\n\n#include \n\n#include \n#include \n\n#include \"../utilities/core/Assert.hpp\"\n\n#include \n#include \n\nusing namespace std;\n\nnamespace openstudio {\nnamespace model {\n\nnamespace detail {\n\n CurveExponentialSkewNormal_Impl::CurveExponentialSkewNormal_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)\n : Curve_Impl(idfObject,model,keepHandle)\n {\n OS_ASSERT(idfObject.iddObject().type() == CurveExponentialSkewNormal::iddObjectType());\n }\n\n CurveExponentialSkewNormal_Impl::CurveExponentialSkewNormal_Impl(const openstudio::detail::WorkspaceObject_Impl& other,\n Model_Impl* model,\n bool keepHandle)\n : Curve_Impl(other,model,keepHandle)\n {\n OS_ASSERT(other.iddObject().type() == CurveExponentialSkewNormal::iddObjectType());\n }\n\n CurveExponentialSkewNormal_Impl::CurveExponentialSkewNormal_Impl(const CurveExponentialSkewNormal_Impl& other,\n Model_Impl* model,\n bool keepHandle)\n : Curve_Impl(other,model,keepHandle)\n {}\n\n const std::vector& CurveExponentialSkewNormal_Impl::outputVariableNames() const\n {\n static std::vector result;\n if (result.empty()){\n }\n return result;\n }\n\n IddObjectType CurveExponentialSkewNormal_Impl::iddObjectType() const {\n return CurveExponentialSkewNormal::iddObjectType();\n }\n\n int CurveExponentialSkewNormal_Impl::numVariables() const {\n return 1;\n }\n\n double CurveExponentialSkewNormal_Impl::evaluate(const std::vector& x) const {\n OS_ASSERT(x.size() == 1u);\n double z1 = (x[0] - coefficient1C1()) / coefficient2C2();\n double z2 = (exp(coefficient3C3() * x[0]) * coefficient4C4() * x[0] - coefficient1C1()) / \n coefficient2C2();\n double z3 = -coefficient1C1()/coefficient4C4();\n double numerator = 1.0 + (z2/abs(z2)) * boost::math::erf(abs(z2)/sqrt(2.0));\n numerator *= exp(-0.5 * pow(z1,2));\n double denominator = 1.0 + (z3/abs(z3)) * boost::math::erf(abs(z3)/sqrt(2.0));\n denominator *= exp(-0.5 * pow(z3,2));\n return numerator/denominator;\n }\n\n double CurveExponentialSkewNormal_Impl::coefficient1C1() const {\n boost::optional value = getDouble(OS_Curve_ExponentialSkewNormalFields::Coefficient1C1,true);\n OS_ASSERT(value);\n return value.get();\n }\n\n double CurveExponentialSkewNormal_Impl::coefficient2C2() const {\n boost::optional value = getDouble(OS_Curve_ExponentialSkewNormalFields::Coefficient2C2,true);\n OS_ASSERT(value);\n return value.get();\n }\n\n double CurveExponentialSkewNormal_Impl::coefficient3C3() const {\n boost::optional value = getDouble(OS_Curve_ExponentialSkewNormalFields::Coefficient3C3,true);\n OS_ASSERT(value);\n return value.get();\n }\n\n double CurveExponentialSkewNormal_Impl::coefficient4C4() const {\n boost::optional value = getDouble(OS_Curve_ExponentialSkewNormalFields::Coefficient4C4,true);\n OS_ASSERT(value);\n return value.get();\n }\n\n double CurveExponentialSkewNormal_Impl::minimumValueofx() const {\n boost::optional value = getDouble(OS_Curve_ExponentialSkewNormalFields::MinimumValueofx,true);\n OS_ASSERT(value);\n return value.get();\n }\n\n double CurveExponentialSkewNormal_Impl::maximumValueofx() const {\n boost::optional value = getDouble(OS_Curve_ExponentialSkewNormalFields::MaximumValueofx,true);\n OS_ASSERT(value);\n return value.get();\n }\n\n boost::optional CurveExponentialSkewNormal_Impl::minimumCurveOutput() const {\n return getDouble(OS_Curve_ExponentialSkewNormalFields::MinimumCurveOutput,true);\n }\n\n boost::optional CurveExponentialSkewNormal_Impl::maximumCurveOutput() const {\n return getDouble(OS_Curve_ExponentialSkewNormalFields::MaximumCurveOutput,true);\n }\n\n std::string CurveExponentialSkewNormal_Impl::inputUnitTypeforx() const {\n boost::optional value = getString(OS_Curve_ExponentialSkewNormalFields::InputUnitTypeforx,true);\n OS_ASSERT(value);\n return value.get();\n }\n\n bool CurveExponentialSkewNormal_Impl::isInputUnitTypeforxDefaulted() const {\n return isEmpty(OS_Curve_ExponentialSkewNormalFields::InputUnitTypeforx);\n }\n\n std::string CurveExponentialSkewNormal_Impl::outputUnitType() const {\n boost::optional value = getString(OS_Curve_ExponentialSkewNormalFields::OutputUnitType,true);\n OS_ASSERT(value);\n return value.get();\n }\n\n bool CurveExponentialSkewNormal_Impl::isOutputUnitTypeDefaulted() const {\n return isEmpty(OS_Curve_ExponentialSkewNormalFields::OutputUnitType);\n }\n\n void CurveExponentialSkewNormal_Impl::setCoefficient1C1(double coefficient1C1) {\n bool result = setDouble(OS_Curve_ExponentialSkewNormalFields::Coefficient1C1, coefficient1C1);\n OS_ASSERT(result);\n }\n\n void CurveExponentialSkewNormal_Impl::setCoefficient2C2(double coefficient2C2) {\n bool result = setDouble(OS_Curve_ExponentialSkewNormalFields::Coefficient2C2, coefficient2C2);\n OS_ASSERT(result);\n }\n\n void CurveExponentialSkewNormal_Impl::setCoefficient3C3(double coefficient3C3) {\n bool result = setDouble(OS_Curve_ExponentialSkewNormalFields::Coefficient3C3, coefficient3C3);\n OS_ASSERT(result);\n }\n\n void CurveExponentialSkewNormal_Impl::setCoefficient4C4(double coefficient4C4) {\n bool result = setDouble(OS_Curve_ExponentialSkewNormalFields::Coefficient4C4, coefficient4C4);\n OS_ASSERT(result);\n }\n\n void CurveExponentialSkewNormal_Impl::setMinimumValueofx(double minimumValueofx) {\n bool result = setDouble(OS_Curve_ExponentialSkewNormalFields::MinimumValueofx, minimumValueofx);\n OS_ASSERT(result);\n }\n\n void CurveExponentialSkewNormal_Impl::setMaximumValueofx(double maximumValueofx) {\n bool result = setDouble(OS_Curve_ExponentialSkewNormalFields::MaximumValueofx, maximumValueofx);\n OS_ASSERT(result);\n }\n\n void CurveExponentialSkewNormal_Impl::setMinimumCurveOutput(boost::optional minimumCurveOutput) {\n bool result = false;\n if (minimumCurveOutput) {\n result = setDouble(OS_Curve_ExponentialSkewNormalFields::MinimumCurveOutput, minimumCurveOutput.get());\n } else {\n result = setString(OS_Curve_ExponentialSkewNormalFields::MinimumCurveOutput, \"\");\n }\n OS_ASSERT(result);\n }\n\n void CurveExponentialSkewNormal_Impl::resetMinimumCurveOutput() {\n bool result = setString(OS_Curve_ExponentialSkewNormalFields::MinimumCurveOutput, \"\");\n OS_ASSERT(result);\n }\n\n void CurveExponentialSkewNormal_Impl::setMaximumCurveOutput(boost::optional maximumCurveOutput) {\n bool result = false;\n if (maximumCurveOutput) {\n result = setDouble(OS_Curve_ExponentialSkewNormalFields::MaximumCurveOutput, maximumCurveOutput.get());\n } else {\n result = setString(OS_Curve_ExponentialSkewNormalFields::MaximumCurveOutput, \"\");\n }\n OS_ASSERT(result);\n }\n\n void CurveExponentialSkewNormal_Impl::resetMaximumCurveOutput() {\n bool result = setString(OS_Curve_ExponentialSkewNormalFields::MaximumCurveOutput, \"\");\n OS_ASSERT(result);\n }\n\n bool CurveExponentialSkewNormal_Impl::setInputUnitTypeforx(std::string inputUnitTypeforx) {\n bool result = setString(OS_Curve_ExponentialSkewNormalFields::InputUnitTypeforx, inputUnitTypeforx);\n return result;\n }\n\n void CurveExponentialSkewNormal_Impl::resetInputUnitTypeforx() {\n bool result = setString(OS_Curve_ExponentialSkewNormalFields::InputUnitTypeforx, \"\");\n OS_ASSERT(result);\n }\n\n bool CurveExponentialSkewNormal_Impl::setOutputUnitType(std::string outputUnitType) {\n bool result = setString(OS_Curve_ExponentialSkewNormalFields::OutputUnitType, outputUnitType);\n return result;\n }\n\n void CurveExponentialSkewNormal_Impl::resetOutputUnitType() {\n bool result = setString(OS_Curve_ExponentialSkewNormalFields::OutputUnitType, \"\");\n OS_ASSERT(result);\n }\n\n} // detail\n\nCurveExponentialSkewNormal::CurveExponentialSkewNormal(const Model& model)\n : Curve(CurveExponentialSkewNormal::iddObjectType(),model)\n{\n OS_ASSERT(getImpl());\n setDouble(OS_Curve_ExponentialSkewNormalFields::Coefficient1C1,1.0);\n setDouble(OS_Curve_ExponentialSkewNormalFields::Coefficient2C2,1.0);\n setDouble(OS_Curve_ExponentialSkewNormalFields::Coefficient3C3,-1.0);\n setDouble(OS_Curve_ExponentialSkewNormalFields::Coefficient4C4,1.0);\n setDouble(OS_Curve_ExponentialSkewNormalFields::MinimumValueofx,-1.0);\n setDouble(OS_Curve_ExponentialSkewNormalFields::MaximumValueofx,1.0);\n}\n\nIddObjectType CurveExponentialSkewNormal::iddObjectType() {\n IddObjectType result(IddObjectType::OS_Curve_ExponentialSkewNormal);\n return result;\n}\n\nstd::vector CurveExponentialSkewNormal::validInputUnitTypeforxValues() {\n return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),\n OS_Curve_ExponentialSkewNormalFields::InputUnitTypeforx);\n}\n\nstd::vector CurveExponentialSkewNormal::validOutputUnitTypeValues() {\n return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),\n OS_Curve_ExponentialSkewNormalFields::OutputUnitType);\n}\n\ndouble CurveExponentialSkewNormal::coefficient1C1() const {\n return getImpl()->coefficient1C1();\n}\n\ndouble CurveExponentialSkewNormal::coefficient2C2() const {\n return getImpl()->coefficient2C2();\n}\n\ndouble CurveExponentialSkewNormal::coefficient3C3() const {\n return getImpl()->coefficient3C3();\n}\n\ndouble CurveExponentialSkewNormal::coefficient4C4() const {\n return getImpl()->coefficient4C4();\n}\n\ndouble CurveExponentialSkewNormal::minimumValueofx() const {\n return getImpl()->minimumValueofx();\n}\n\ndouble CurveExponentialSkewNormal::maximumValueofx() const {\n return getImpl()->maximumValueofx();\n}\n\nboost::optional CurveExponentialSkewNormal::minimumCurveOutput() const {\n return getImpl()->minimumCurveOutput();\n}\n\nboost::optional CurveExponentialSkewNormal::maximumCurveOutput() const {\n return getImpl()->maximumCurveOutput();\n}\n\nstd::string CurveExponentialSkewNormal::inputUnitTypeforx() const {\n return getImpl()->inputUnitTypeforx();\n}\n\nbool CurveExponentialSkewNormal::isInputUnitTypeforxDefaulted() const {\n return getImpl()->isInputUnitTypeforxDefaulted();\n}\n\nstd::string CurveExponentialSkewNormal::outputUnitType() const {\n return getImpl()->outputUnitType();\n}\n\nbool CurveExponentialSkewNormal::isOutputUnitTypeDefaulted() const {\n return getImpl()->isOutputUnitTypeDefaulted();\n}\n\nvoid CurveExponentialSkewNormal::setCoefficient1C1(double coefficient1C1) {\n getImpl()->setCoefficient1C1(coefficient1C1);\n}\n\nvoid CurveExponentialSkewNormal::setCoefficient2C2(double coefficient2C2) {\n getImpl()->setCoefficient2C2(coefficient2C2);\n}\n\nvoid CurveExponentialSkewNormal::setCoefficient3C3(double coefficient3C3) {\n getImpl()->setCoefficient3C3(coefficient3C3);\n}\n\nvoid CurveExponentialSkewNormal::setCoefficient4C4(double coefficient4C4) {\n getImpl()->setCoefficient4C4(coefficient4C4);\n}\n\nvoid CurveExponentialSkewNormal::setMinimumValueofx(double minimumValueofx) {\n getImpl()->setMinimumValueofx(minimumValueofx);\n}\n\nvoid CurveExponentialSkewNormal::setMaximumValueofx(double maximumValueofx) {\n getImpl()->setMaximumValueofx(maximumValueofx);\n}\n\nvoid CurveExponentialSkewNormal::setMinimumCurveOutput(double minimumCurveOutput) {\n getImpl()->setMinimumCurveOutput(minimumCurveOutput);\n}\n\nvoid CurveExponentialSkewNormal::resetMinimumCurveOutput() {\n getImpl()->resetMinimumCurveOutput();\n}\n\nvoid CurveExponentialSkewNormal::setMaximumCurveOutput(double maximumCurveOutput) {\n getImpl()->setMaximumCurveOutput(maximumCurveOutput);\n}\n\nvoid CurveExponentialSkewNormal::resetMaximumCurveOutput() {\n getImpl()->resetMaximumCurveOutput();\n}\n\nbool CurveExponentialSkewNormal::setInputUnitTypeforx(std::string inputUnitTypeforx) {\n return getImpl()->setInputUnitTypeforx(inputUnitTypeforx);\n}\n\nvoid CurveExponentialSkewNormal::resetInputUnitTypeforx() {\n getImpl()->resetInputUnitTypeforx();\n}\n\nbool CurveExponentialSkewNormal::setOutputUnitType(std::string outputUnitType) {\n return getImpl()->setOutputUnitType(outputUnitType);\n}\n\nvoid CurveExponentialSkewNormal::resetOutputUnitType() {\n getImpl()->resetOutputUnitType();\n}\n\n/// @cond\nCurveExponentialSkewNormal::CurveExponentialSkewNormal(std::shared_ptr impl)\n : Curve(impl)\n{}\n/// @endcond\n\n} // model\n} // openstudio\n\n", "meta": {"hexsha": "a9b629eb9187dab54e9a5d06f6618875207d8bc1", "size": 16155, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "openstudiocore/src/model/CurveExponentialSkewNormal.cpp", "max_stars_repo_name": "OpenStudioThailand/OpenStudio", "max_stars_repo_head_hexsha": "4e2173955e687ef1b934904acc10939ac0bed52f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2017-10-13T09:23:04.000Z", "max_stars_repo_stars_event_max_datetime": "2017-10-13T09:23:04.000Z", "max_issues_repo_path": "openstudiocore/src/model/CurveExponentialSkewNormal.cpp", "max_issues_repo_name": "OpenStudioThailand/OpenStudio", "max_issues_repo_head_hexsha": "4e2173955e687ef1b934904acc10939ac0bed52f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "openstudiocore/src/model/CurveExponentialSkewNormal.cpp", "max_forks_repo_name": "OpenStudioThailand/OpenStudio", "max_forks_repo_head_hexsha": "4e2173955e687ef1b934904acc10939ac0bed52f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-03-20T13:19:42.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-20T13:19:42.000Z", "avg_line_length": 42.0703125, "max_line_length": 130, "alphanum_fraction": 0.7636025998, "num_tokens": 3918, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6992544335934765, "lm_q2_score": 0.5, "lm_q1q2_score": 0.34962721679673825}} {"text": "#ifndef SPARSE_PATCHMAP_H\n#define SPARSE_PATCHMAP_H\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"wmath_forward.hpp\"\n#include \"wmath_bits.hpp\"\n#include \"wmath_hash.hpp\"\n#include \"wmath_math.hpp\"\n#include \"hashed_array_tree.hpp\"\n#ifdef PATCHMAP_STAT\nsize_t recursion_depth;\nsize_t shift_count;\n#endif\n\nnamespace{\n template\n double frac(const T& n){\n return n*pow(0.5,std::numeric_limits::digits);\n }\n}\n\nnamespace wmath{\n \n using std::allocator_traits;\n\n template\n struct dummy_comp{ // dummy comparator for when we don't need a comparator\n constexpr bool operator()(const T&,const T&) const {return false;}\n };\n\n struct empty{\n };\n \n template,\n class equal = std::equal_to,\n class comp = typename conditional::value,\n dummy_comp,\n std::less>::type,\n class alloc = typename std::allocator<\n typename conditional<\n std::is_same::value,\n std::pair,\n std::pair\n >::type>,\n /*class alloc = typename boost::container::allocator<\n typename conditional<\n std::is_same::value,\n std::pair,\n std::pair\n >::type,2>,*/\n bool dynamic = true\n >\n class sparse_patchmap{\n public:\n typedef alloc allocator_type;\n typedef typename alloc::value_type value_type;\n typedef typename alloc::pointer value_pointer;\n typedef typename alloc::reference reference;\n typedef typename alloc::const_reference const_reference;\n typedef typename alloc::difference_type difference_type;\n typedef typename alloc::size_type size_type;\n typedef typename std::result_of::type hash_type;\n typedef typename conditional::value,\n key_type,\n mapped_type>::type\n _mapped_type;\n private:\n size_type num_data = 0;\n size_type datasize = 0;\n size_type masksize = 0;\n allocator_type allocator;\n boost::container::allocator maskallocator;\n hashed_array_tree data;\n hashed_array_tree< size_type,boost::container::allocator>\n mask;\n comp comparator;\n equal equator;\n hash hasher;\n using uphold_iterator_validity = true_type;\n /* TODO\n size_type const inline masksize() const {\n return (datasize+digits()-1)/digits();\n }\n */\n template\n const key_type& key_of(T&& value) const {\n if constexpr (is_same::value) return value;\n else return value.first;\n }\n size_type inline map(\n const hash_type& h,\n const hash_type& n\n ) const {\n return get<0>(long_mul(h,n));\n }\n size_type inline map(const hash_type& h) const {\n return map(h,datasize);\n }\n size_type inline map_diff(\n const hash_type& h0,\n const hash_type& h1,\n const hash_type& n\n ) const {\n const auto lm = long_mul(h0-h1,n);\n return get<0>(lm);\n }\n size_type inline map_diff(\n const hash_type& h0,\n const hash_type& h1\n ) const {\n return map_diff(h0,h1,datasize);\n }\n size_type inline map_diff_round(\n const hash_type& h0,\n const hash_type& h1,\n const hash_type& n\n ) const {\n const auto lm = long_mul(h0-h1,n);\n return get<0>(lm)+(get<1>(lm)>((~hash_type(0))>>1));\n }\n size_type inline map_diff_round(\n const hash_type& h0,\n const hash_type& h1\n ) const {\n return map_diff_round(h0,h1,datasize);\n }\n hash_type inline order(const key_type& k) const {\n return distribute(hasher(k));\n }\n bool inline is_less(\n const key_type& a,\n const key_type& b,\n const hash_type& oa,\n const hash_type& ob\n ) const {\n if constexpr (is_injective::value){\n assert(equator(a,b)==(oa==ob));\n if (oaob) return false;\n return comparator(a,b);\n }\n }\n bool inline is_less(\n const key_type& a,\n const key_type& b,\n const hash_type& oa\n ) const {\n return is_less(a,b,oa,order(b));\n }\n bool inline is_less(const key_type& a,const key_type& b) const {\n return is_less(a,b,order(a),order(b));\n }\n bool inline is_more(\n const key_type& a,\n const key_type& b,\n const hash_type& oa,\n const hash_type& ob\n ) const {\n if constexpr (is_injective::value){\n assert(equator(a,b)==(oa==ob));\n if (oa>ob) return true;\n else return false;\n } else {\n if (oa>ob) return true;\n if (oa();\n const size_type j = n%digits();\n assert(i()-j-1)));\n }\n bool inline is_set_any(\n const size_type& lo,\n const size_type& hi) const {\n const size_type k0 = lo/digits();\n const size_type l0 = lo%digits();\n const size_type m0 = (~size_type(0))>>l0;\n const size_type k1 = hi/digits();\n const size_type l1 = hi%digits();\n const size_type m1 = (~size_type(0))<<(digits()-l1-1);\n if (k0==k1) return ((m0&m1&mask[k0])!=0);\n if (((m0&mask[k0])!=0)||((m1&mask[k1])!=0)) return true;\n for (size_type i = k0+1;i!=k1;++i)\n if (mask[i]!=0) return true;\n return false;\n }\n void inline set(const size_type& n) {\n const size_type i = n/digits();\n const size_type j = n%digits();\n mask[i]|=size_type(1)<<(digits()-j-1);\n }\n void inline unset(const size_type& n) {\n const size_type i = n/digits();\n const size_type j = n%digits();\n mask[i]&=((~size_type(0))^(size_type(1)<<(digits()-j-1)));\n }\n void inline swap_set(const size_type& i,const size_type& j){\n if (is_set(i)==is_set(j)) return;\n if (is_set(i)){\n set(j);\n unset(i);\n }else{\n set(i);\n unset(j);\n }\n }\n bool inline index_key_is_less(const size_type& i,const key_type& k) const{\n if (is_set(i)) return is_less(data[i].first,k);\n return i=datasize) return ~size_type(0);\n while(true){\n const size_type k = i/digits();\n const size_type l = i%digits();\n const size_type m = (~size_type(0))>>l; \n assert(k()-l);\n const size_type s = clz(p);\n if (s==0) return i;\n i+=s;\n if (i>=datasize) return ~size_type(0);\n }\n }\n // search for free bucket in decreasing order\n size_type inline search_free_dec(size_type i) const {\n while(true){\n const size_type k = i/digits();\n const size_type l = i%digits();\n const size_type m = (~size_type(0))<<(digits()-l-1);\n assert(k>(digits()-l-1));\n if (k!=0) p|=shl(~(mask[k-1]&(~m)),l+1);\n const size_type s = ctz(p);\n if (s==0){\n assert(!is_set(i));\n return i;\n }\n i-=s;\n if (i>=datasize) return ~size_type(0);\n }\n }\n // search for free bucket in increasing order\n size_type inline search_free_inc(size_type i) const {\n while(true){\n const size_type k = i/digits();\n const size_type l = i%digits();\n const size_type m = (~size_type(0))>>l; \n assert(k()-l);\n const size_type s = clz(p);\n if (s==0){\n assert(!is_set(i));\n return i;\n }\n i+=s;\n if (i>=datasize) return ~size_type(0);\n }\n }\n // search for free bucket bidirectional\n size_type inline search_free_bidir_v0(size_type i) const {\n const size_type k = search_free_inc(i);\n const size_type l = search_free_dec(i);\n assert((k=datasize) i=l;\n else if (l>=datasize) i=k;\n else if (k-i 0.98\n size_type inline search_free_bidir(const size_type& n) const {\n size_type i = n, j = n, si=~size_type(0),sj=~size_type(0);\n while(true){\n if ((i!=~size_type(0))&&si){\n const size_type k = i/digits();\n const size_type l = i%digits();\n const size_type m = (~size_type(0))>>l; \n size_type p = (~(mask[k]&m))<()-l);\n si= clz(p);\n }\n if (si==0){\n if (j==~size_type(0)) return i;\n if (i-n+digits()<=n-j) return i;\n } else {\n i+=si;\n if (i>=datasize) i=~size_type(0);\n if ((i&j)==~size_type(0)) return ~size_type(0);\n }\n if ((j!=~size_type(0))&&sj){\n const size_type k = j/digits();\n const size_type l = j%digits();\n const size_type m = (~size_type(0))<<(digits()-l-1);\n size_type p = ((~(mask[k]&m))>>(digits()-l-1));\n if (k!=0) p|=shl(~(mask[k-1]&(~m)),l+1);\n sj= ctz(p);\n }\n if (sj==0) {\n if (i==~size_type(0)) return j;\n if (n-j+digits()<=i-n) return j;\n } else {\n j-=sj;\n if (j>=datasize) j=~size_type(0);\n if ((i&j)==~size_type(0)) return ~size_type(0);\n }\n if ((si==0)&&(sj==0)){\n if (i-n<=n-j) return i;\n else return j;\n }\n }\n return ~size_type(0);\n }\n size_type const inline reserve_node(\n const key_type& key,\n const size_type& mok,\n const hash_type& ok\n ){\n#ifdef PATCHMAP_STAT\n shift_count = 0;\n#endif\n assert(mok=datasize) break;\n if (!is_set(i+1)) break;\n if (is_less(key,data[i+1].first,ok,order(data[i+1].first))) break; \n swap(data[i],data[i+1]);\n ++i;\n }\n#ifdef PATCHMAP_STAT\n shift_count = i-j;\n#endif\n return i;\n }\n size_type inline reserve_node(\n const key_type& key,\n const size_type& hint){\n const hash_type ok = order(key);\n return reserve_node(key,hint,ok);\n }\n size_type inline reserve_node(const key_type& key){\n const hash_type ok = order(key);\n const size_type hint = map(ok);\n assert(hint::value) {\n if (index_key_is_less(mi,key)){\n if (milo) return find_node_binary(key,ok,lo,mi-1);\n else return ~size_type(0);\n }\n } else {\n if (index_key_is_less(mi,key)){\n if (milo) return find_node_binary(key,ok,lo,mi-1);\n else return ~size_type(0);\n }\n }\n }\n \n size_type inline interpol(\n const hash_type& ok,\n const hash_type& olo,\n const hash_type& ohi,\n const size_type& lo,\n const size_type& hi\n ) const {\n auto lm = long_mul(size_type(ok-olo),hi-lo);\n // this is theoretically better but not worth the time\n //const hash_type tmp = get<1>(lm)+(ohi-olo)/2;\n //if (tmp(lm)) ++get<0>(lm);\n //get<1>(lm) = tmp;\n const size_type n = clz(get<0>(lm));\n const size_type m = digits()-n;\n const hash_type den = (ohi-olo)>>m;\n const hash_type nom = (get<0>(lm)<(lm)>>m);\n return lo+nom/den;\n }\n\n size_type inline find_node_linear(\n const key_type& k,\n const size_type& lo,\n const size_type& hi) const {\n size_type i = lo;\n while(true){\n if (is_set(i)) if (equator(data[i].first,k)) return i;\n if (i==hi) return ~size_type(0);\n ++i;\n }\n }\n \n size_type inline find_node_interpol(\n const key_type& k,\n const hash_type& ok,\n const size_type& mok,\n size_type lo,\n hash_type olo,\n bool is_set_lo,\n size_type hi,\n size_type ohi,\n bool is_set_hi\n ) const {\n assert(lo<=hi||datasize==0);\n size_type mi;\n while(true) {\n if (!(lo>1);\n } else if (is_set_lo) {\n mi = lo + ((hi-lo+2)>>2);\n } else if (is_set_hi) {\n mi = hi - ((hi-lo+2)>>2);\n } else {\n return ~size_type(0);\n }\n } else {\n if (is_set_hi && is_set_lo) {\n mi = interpol(ok,olo,ohi,lo,hi);\n } else if (is_set_lo) {\n const size_type st = map_diff(ok,olo);\n mi = lo+stmok) {\n hi = mi;\n is_set_hi=false;\n continue;\n }\n return ~size_type(0);\n }\n if (equator(k,data[mi].first)) return mi;\n const hash_type omi = order(data[mi].first);\n if (okomi) {\n lo = mi;\n olo = omi;\n is_set_lo = true;\n continue;\n }\n if constexpr (is_injective::value) {\n return ~size_type(0);\n } else {\n if (kdata[mi].first) {\n lo = mi;\n olo = omi;\n is_set_lo = true;\n continue;\n }\n }\n return ~size_type(0);\n }\n return ~size_t(0);\n }\n\n size_type inline find_node(\n const key_type & k,\n const hash_type& ok,\n const size_type& mok)\n const {\n#ifdef PATCHMAP_STAT\n recursion_depth=0;\n#endif\n assert((mok\n typename conditional::value,\n const _mapped_type&,\n _mapped_type&>::type\n static inline const_noconst_at(map_type& hashmap,const key_type& k) {\n size_type i = hashmap.find_node(k);\n if (i::value)\n return hashmap.data[i].first;\n else return\n hashmap.data[i].second;\n } else throw std::out_of_range(\n std::string(typeid(hashmap).name())\n +\".const_noconst_at(\"+typeid(k).name()+\" k)\"\n +\"key not found, array index \"\n +to_string(i)+\" out of bounds\"\n );\n }\n public:\n void print() const {\n cerr << datasize << \" \" << num_data << endl;\n for (size_type i=0;i!=datasize;++i) {\n cout << std::fixed << std::setprecision(16);\n const size_type ok = order(data[i].first);\n const size_type mok = map(ok);\n if (is_set(i)) cout << setw(6) << i;\n else cout << \" \" ;\n cout << setw(20) << frac(uint32_t(ok))\n << setw(20) << frac(uint32_t(data[i].second));\n if (is_set(i)) cout << setw( 8) << mok\n << setw( 8) << int(mok)-int(i);\n else cout << setw( 8) << i\n << setw( 8) << 0;\n cout << endl;\n }\n cout << endl;\n }\n size_type erase(\n const key_type& k,\n const hash_type& ok,\n const size_type& hint){\n size_type i = find_node(k,ok,hint);\n if (i>=datasize) return 0;\n //cout << \"erasing \" << wmath::frac(ok) << endl;\n //cout << \"found at \" << i << endl;\n const size_type j = i;\n while(true){\n if (i+1==datasize) break;\n if (!is_set(i+1)) break;\n if (map(order(data[i+1].first))>i) break;\n swap(data[i],data[i+1]);\n ++i;\n }\n if (i==j){\n while(true){\n if (i==0) break;\n if (!is_set(i-1)) break;\n if (map(order(data[i-1].first))()-1)/digits();\n if (n>datasize) {\n data.resize(new_datasize);\n mask.resize(new_masksize);\n const size_type old_masksize = masksize;\n masksize = new_masksize;\n const size_type old_datasize = datasize;\n datasize = new_datasize;\n for (size_type i=old_masksize;i!=new_masksize;++i) mask[i]=0;\n num_data = 0;\n for (size_type n=old_datasize;n!=~size_type(0);--n) {\n const size_type i = n/digits();\n const size_type j = n%digits();\n if (mask[i]&(size_type(1)<<(digits()-j-1))) {\n const value_type tmp = move(data[n]);\n unset(n);\n const size_type l = reserve_node(tmp.first);\n data[l] = move(tmp);\n set(l);\n }\n }\n } else {\n const size_type old_datasize = datasize;\n datasize = new_datasize;\n masksize = new_masksize;\n num_data = 0;\n for (size_type n=0;n!=old_datasize;++n) {\n const size_type i = n/digits();\n const size_type j = n%digits();\n if (mask[i]&(size_type(1)<<(digits()-j-1))) {\n const value_type tmp = move(data[n]);\n unset(n);\n const size_type l = reserve_node(tmp.first);\n data[l] = move(tmp);\n set(l);\n }\n }\n data.resize(datasize);\n mask.resize(masksize);\n }\n }\n size_type inline size() const { return num_data; }\n size_type const test_size() const {\n size_type test = 0;\n for (size_type i=0;i!=datasize;++i) test += is_set(i);\n return test;\n }\n void test_chunks() const {\n for (size_type i=0;i!=masksize;++i){\n cout << popcount(mask[i]) << endl;\n }\n }\n bool check_ordering() const {\n bool ordered = true;\n for (size_type i=0,j=1;j0 ) if (!index_index_is_less(i-1,i)) return false;\n if (i+1();\n } else {\n //nextsize = 50*datasize/31;\n //nextsize = 48*datasize/31;\n //nextsize = 47*datasize/31;\n //nextsize = 47*datasize/37;\n //nextsize = 53*datasize/41;\n //nextsize = (113*datasize+44)/89;\n nextsize = (107*datasize+89)/89;\n nextsize = (nextsize+digits()-1)/digits();\n nextsize = mask.next_size(nextsize);\n nextsize*= digits();\n }\n resize(nextsize);\n }\n _mapped_type& operator[](const key_type& k){\n const size_type i = find_node(k);\n if (i::value) return data[i].first;\n else return data[i].second;\n }\n //assert(find_node_bruteforce(k)==~size_type(0));\n ensure_size();\n //assert(check_ordering());\n const size_type j = reserve_node(k);\n if constexpr (is_same::value) {\n allocator_traits::construct(\n allocator,&data[j],k,wmath::empty());\n } else {\n allocator_traits::construct(\n allocator,&data[j],k,mapped_type());\n }\n //assert(check_ordering());\n //assert(find_node_bruteforce(k)==j);\n //assert(find_node(k)==j);\n assert(check_ordering(j));\n if constexpr (is_same::value) return data[i].first;\n else return data[j].second;\n }\n const _mapped_type& operator[](const key_type& k) const {\n const size_type i = find_node(k);\n assert(i::value) return data[i].first;\n return data[i].second; // this is only valid if key exists!\n }\n _mapped_type& at(const key_type& k){\n return const_noconst_at(*this,k);\n }\n const _mapped_type& at(const key_type& k) const {\n return const_noconst_at(*this,k);\n }\n size_type const inline count(const key_type& k) const {\n //assert(check_ordering());\n //assert(find_node(k)==find_node_bruteforce(k));\n return (find_node(k) hist;\n for (size_type i=0;i!=datasize;++i)\n ++hist[int(map(order(data[i].first)))-int(i)];\n for (auto it=hist.begin();it!=hist.end();++it)\n cout << it->first << \" \" << it->second << endl;\n }\n equal key_eq() const{ // get key equivalence predicate\n return equal{};\n }\n comp key_comp() const{ // get key order predicate\n return comp{};\n }\n alloc get_allocator() const{\n return allocator;\n }\n hash hash_function() const{ // get hash function\n return hash{};\n } \n template\n class const_noconst_iterator {\n friend class sparse_patchmap;\n public:\n size_type hint;\n key_type key;\n typename conditional::type map;\n private:\n void inline update_hint(){\n if constexpr (!uphold_iterator_validity::value) return;\n if (hintdatasize)\n if (equal{}(map->data[hint].first,key)) return;\n hint = map->find_node(key,hint);\n if (hint>=map->datasize) hint = ~size_type(0);\n }\n void inline unsafe_increment(){ // assuming hint is valid\n //cout << \"unsafe_increment() \" << hint << \" \" << key << endl;\n if (++hint>=map->datasize){\n //cout << \"test1\" << endl;\n //cout << \"becoming an end()\" << endl;\n hint=~size_type(0);\n return;\n }\n while(true){\n //cout << \"test2\" << endl;\n const size_type k = hint/digits();\n const size_type l = hint%digits();\n const size_type m = (~size_type(0))>>l; \n assert(kmasksize);\n size_type p = (map->mask[k]&m)<masksize)\n p|=shr(map->mask[k+1]&(~m),digits()-l);\n const size_type s = clz(p);\n if (s==0) break;\n hint+=s;\n //cout << hint << \" \" << s << endl;\n if (hint>=map->datasize){\n //cout << \"test3\" << endl;\n //cout << \"becoming an end()\" << endl;\n hint=~size_type(0);\n return;\n }\n }\n //cout << \"test4\" << endl;\n //cout << \"new hint=\" << hint << endl;\n key = map->data[hint].first;\n //cout << \"new key=\" << key << endl;\n }\n void inline unsafe_decrement(){ // assuming hint is valid\n if (--hint>=map->datasize){\n hint=~size_type(0);\n return;\n }\n while(true){\n const size_type k = hint/digits();\n const size_type l = hint%digits();\n const size_type m = (~size_type(0))<<(digits()-l-1);\n assert(kmasksize);\n size_type p = (map->mask[k]&m)>>(digits()-l-1);\n if (k!=0) p|=shl(map->mask[k-1]&(~m),l+1);\n const size_type s = ctz(p);\n if (s==0) break;\n hint-=s;\n if (hint>=map->datasize){\n hint=~size_type(0);\n return;\n }\n }\n key = map->data[hint].first;\n }\n template\n difference_type inline friend diff(\n const_noconst_iterator& it0,\n const_noconst_iterator& it1){\n if (it1hint/digits();\n const size_type l0 = it0->hint%digits();\n const size_type m0 = (~size_type(0))>>l0;\n const size_type k1 = it1->hint/digits();\n const size_type l1 = it1->hint%digits();\n const size_type m1 = (~size_type(0))<<(digits()-l1-1);\n if (k0==k1) return popcount(m0&m1&it0.map->mask[k0])-1;\n size_type d = popcount(m0&it0.map->mask[k0])\n +popcount(m1&it1.map->mask[k1]);\n for (size_type i = k0+1;i!=k1;++i)\n d+=popcount(it0.map->mask[i]);\n return d;\n }\n void inline add(const size_type& n){\n update_hint();\n size_type k = hint/digits();\n const size_type l = hint%digits();\n const size_type m = (~size_type(0))>>l;\n size_type i = 0;\n size_type p = popcount(map->mask[k]&m)-1; \n while (i+p=map->mapsize){\n hint=~size_type(0);\n return;\n }\n hint+=digits();\n p = popcount(map->mask[k]);\n }\n for (;i!=n;++i) unsafe_increment();\n key = map->data[hint].first;\n }\n void inline sub(const size_type& n){\n update_hint();\n size_type k = hint/digits();\n const size_type l = hint%digits();\n const size_type m = (~size_type(0))<<(digits()-l-1);\n size_type i = 0;\n size_type p = popcount(map->mask[k]&m)-1;\n while (i+p=map->mapsize){\n hint=~size_type(0);\n return;\n }\n hint+=digits();\n p = popcount(map->mask[k]);\n }\n for (;i!=n;++i) unsafe_decrement();\n key = map->data[hint].first;\n }\n public:\n typedef typename alloc::difference_type difference_type;\n typedef typename alloc::value_type value_type;\n typedef typename\n conditional::type\n reference;\n typedef typename\n conditional::type\n pointer;\n typedef std::bidirectional_iterator_tag iterator_category;\n const_noconst_iterator(){\n //cout << \"constructor 0\" << endl;\n }\n const_noconst_iterator(\n const size_t& hint,\n typename conditional::type map)\n :hint(hint),key(key_type{}),map(map){\n //cout << \"constructor 1 \" << hint << endl;\n }\n const_noconst_iterator(\n const size_t& hint,\n const key_type& key,\n typename conditional::type map)\n :hint(hint),key(key),map(map) {\n //cout << \"constructor 2 \" << hint << endl;\n }\n ~const_noconst_iterator(){\n //cout << \"destructor of const_noconst_iterator \" << is_const << endl;\n //cout << hint << endl;\n }\n // copy constructor\n template\n const_noconst_iterator(const const_noconst_iterator& o)\n :hint(o.hint),key(o.key),map(o.map){\n //cout << \"copy constructor\" << endl;\n }\n // move constructor\n template\n const_noconst_iterator(\n const_noconst_iterator&& o) noexcept{\n //cout << \"move constructor\" << endl;\n swap(hint,o.hint);\n swap(key,o.key);\n swap(map,o.map);\n }\n // copy assignment\n template\n const_noconst_iterator& operator=(\n const const_noconst_iterator& other){\n //cout << \"copy assignment\" << endl;\n return (*this=const_noconst_iterator(other));\n }\n template\n bool operator==(\n const const_noconst_iterator& o) const {\n //cout << \"comparing \" << hint << \" \" << key << \" with \"\n // << o.hint << \" \" << key << endl;\n if ((hint>=map->datasize)&&(o.hint>=o.map->datasize)) return true;\n if ((hint>=map->datasize)||(o.hint>=o.map->datasize)) return false;\n if (key!=o.key) return false;\n return true;\n }\n template\n bool operator!=(\n const const_noconst_iterator& o) const{\n return !((*this)==o);\n }\n template\n bool operator< (\n const const_noconst_iterator& o) const{\n if ((o.hintdatasize)){\n if (hintdatasize){\n return comp(key,o.key);\n }else{\n return false;\n }\n } else {\n return false;\n }\n }\n template\n bool operator> (\n const const_noconst_iterator& o) const{\n if ((o.hintdatasize)){\n if (hintdatasize){\n return (!comp(key,o.key))&&(!equal(key,o.key));\n }else{\n return true;\n }\n } else {\n return false;\n }\n }\n template\n bool operator<=(\n const const_noconst_iterator& o) const{\n if ((o.hintdatasize)){\n if (hintdatasize){\n return comp(key,o.key)||equal(key,o.key);\n }else{\n return false;\n }\n } else {\n return true;\n }\n }\n template\n bool operator>=(\n const const_noconst_iterator& o) const{\n if ((o.hintdatasize)){\n if (hintdatasize){\n return !comp(key,o.key);\n }else{\n return true;\n }\n } else {\n return true;\n }\n }\n const_noconst_iterator& operator++(){ // prefix\n //cout << \"operator++()\" << endl;\n update_hint();\n unsafe_increment();\n return *this;\n }\n const_noconst_iterator operator++(int){ // postfix\n update_hint();\n iterator pre(*this);\n unsafe_increment();\n return pre;\n }\n const_noconst_iterator& operator--(){ // prefix\n update_hint();\n unsafe_decrement();\n return *this;\n }\n const_noconst_iterator operator--(int){ // postfix\n update_hint();\n iterator pre(*this);\n unsafe_decrement();\n return pre;\n }\n // not a random_acces_iterator but we can still do better than default\n template\n difference_type operator-(\n const const_noconst_iterator& o) const {\n iterator it0(*this);\n iterator it1(o);\n return diff(it0,it1);\n }\n const_noconst_iterator& operator+=(const size_type& n){\n add(n);\n return *this;\n }\n const_noconst_iterator operator+(const size_type& n) const {\n return (const_noconst_iterator(*this)+=n);\n }\n friend const_noconst_iterator operator+(\n const size_type& n,\n const const_noconst_iterator& it){\n return (const_noconst_iterator(it)+=n);\n }\n const_noconst_iterator& operator-=(const size_type& n){\n sub(n);\n return *this;\n }\n const_noconst_iterator operator-(const size_type& n) const{\n return (const_noconst_iterator(*this)-=n);\n }\n reference operator*() {\n update_hint();\n return map->data[hint];\n }\n pointer operator->() {\n update_hint();\n return &(map->data[hint]);\n }\n reference operator*() const {\n size_type i;\n if (hint>=map->datasize){\n i = map->find_node(key);\n } else if (map->data[hint]!=key){\n i = map->find_node(key,hint);\n } else {\n i = hint;\n }\n return map->data[i];\n }\n pointer operator->() const {\n size_type i;\n if (hint>=map->datasize){\n i = map->find_node(key);\n } else if (map->data[hint]!=key){\n i = map->find_node(key,hint);\n } else {\n i = hint;\n }\n return &(map->data[i]);\n }\n };\n typedef const_noconst_iterator iterator;\n typedef const_noconst_iterator const_iterator; \n iterator begin(){\n //cout << \"begin()\" << endl;\n const size_type i = find_first();\n //cout << \"this should call constructor 2\" << endl;\n return iterator(i,data[i].first,this);\n }\n const_iterator begin() const {\n //cout << \"begin()\" << endl;\n const size_type i = find_first();\n //cout << \"this should call constructor 2\" << endl;\n return const_iterator(i,data[i].first,this);\n }\n const_iterator cbegin() const {\n //cout << \"cbegin()\" << endl;\n const size_type i = find_first();\n //cout << \"this should call constructor 2\" << endl;\n return const_iterator(i,data[i].first,this);\n }\n iterator end() {\n //cout << \"end()\" << endl;\n const size_type i = find_first();\n //cout << \"this should call constructor 1\" << endl;\n return iterator(~size_type(0),this);\n }\n const_iterator end() const {\n //cout << \"end()\" << endl;\n //cout << \"this should call constructor 2\" << endl;\n return const_iterator(~size_type(0),this);\n }\n const_iterator cend() const {\n //cout << \"cend()\" << endl;\n //cout << \"this should call constructor 2\" << endl;\n return const_iterator(~size_type(0),this);\n }\n size_type max_size() const{return numeric_limits::max();}\n bool empty() const{return (num_data==0);}\n size_type bucket_count() const{return datasize;}\n size_type max_bucket_count() const{return numeric_limits::max();}\n void rehash(const size_type& n) { if (n>=size()) resize(n); }\n void reserve(const size_type& n){ if (3*n>=2*(size()+1)) resize(n*3/2); }\n pair insert ( const value_type& val ){\n const size_type i = find_node(key_of(val));\n if (i::construct(allocator,data+j,val);\n return {{j,key_of(val),this},true};\n }\n template \n pair insert ( P&& val ){\n const size_type i = find_node(key_of(val));\n if (i::value)\n allocator_traits::construct(allocator,data+j,\n std::pair(val,wmath::empty{}));\n else\n allocator_traits::construct(allocator,data+j,val);\n return {{j,key_of(val),this},true};\n }\n iterator insert ( const_iterator hint, const value_type& val ){\n const size_type i = find_node(key_of(val),hint.hint);\n if (i::value)\n allocator_traits::construct(allocator,data+j,{val,{}});\n else\n allocator_traits::construct(allocator,data+j,val);\n return {{j,key_of(val),this},true};\n }\n template \n iterator insert ( const_iterator hint, P&& val ){\n const size_type i = find_node(key_of(val),hint.hint);\n if (i::value)\n allocator_traits::construct(allocator,data+j,{val,{}});\n else\n allocator_traits::construct(allocator,data+j,val);\n return {{j,key_of(val),this},true};\n }\n template \n void insert ( InputIterator first, InputIterator last ){\n for (auto it(first);it!=last;++it){\n insert(*it);\n }\n }\n void insert ( initializer_list il ){\n insert(il.begin(),il.end());\n }\n template \n pair emplace ( Args&&... args ){\n insert(value_type(args...));\n }\n template \n iterator emplace_hint(const_iterator position,Args&&... args){\n insert(position,value_type(args...));\n }\n pair equal_range(const key_type& k){\n const size_type i = find_node(k);\n if (i>=datasize) return {end(),end()};\n iterator lo(i,data[i].first,this);\n iterator hi(lo);\n ++hi;\n return {lo,hi};\n }\n pair\n equal_range ( const key_type& k ) const{\n const size_type i = find_node(k);\n if (i>=datasize) return {cend(),cend()};\n iterator lo(i,data[i].first,this);\n iterator hi(lo);\n ++hi;\n return {lo,hi};\n }\n float load_factor() const noexcept{\n return float(num_data)/float(datasize);\n }\n float average_patchsize() const noexcept{\n double avg = 0;\n double counter = 0;\n for (size_type i=0;i\n iterator erase(const_noconst_iterator position){\n iterator it(position);\n ++it;\n erase(position.key);//,position.hint);\n return it;\n }\n template\n iterator erase(\n const_noconst_iterator first,\n const_noconst_iterator last){\n for (auto it=first;it!=last;it=erase(it));\n }\n }; \n}\n\n\n\n#endif // SPARSE_PATCHMAP_H\n", "meta": {"hexsha": "b36cad5c5bf6be0fdd741015e31f36a1d55e90f1", "size": 50172, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/common/wflign/deps/patchmap/sparse_patchmap.hpp", "max_stars_repo_name": "AndreaGuarracino/edyeet", "max_stars_repo_head_hexsha": "776a0c82e7ebf9ea7def055d12e19d6bb0aa5383", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 92.0, "max_stars_repo_stars_event_min_datetime": "2019-09-11T05:17:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T09:54:06.000Z", "max_issues_repo_path": "deps/patchmap/sparse_patchmap.hpp", "max_issues_repo_name": "AndreaGuarracino/wflign", "max_issues_repo_head_hexsha": "8d991cbb6ba6821e1765cce92338dbacafbe278e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 9.0, "max_issues_repo_issues_event_min_datetime": "2020-09-01T02:33:34.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-13T20:01:26.000Z", "max_forks_repo_path": "deps/patchmap/sparse_patchmap.hpp", "max_forks_repo_name": "AndreaGuarracino/wflign", "max_forks_repo_head_hexsha": "8d991cbb6ba6821e1765cce92338dbacafbe278e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2020-08-18T14:24:55.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-08T13:33:12.000Z", "avg_line_length": 35.5577604536, "max_line_length": 81, "alphanum_fraction": 0.5106234553, "num_tokens": 12240, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6992544210587586, "lm_q2_score": 0.5, "lm_q1q2_score": 0.3496272105293793}} {"text": "// Copyright 2006. Peter Gottschling, Matthias Troyer, Rolf Bonderer\n// Software License for MTL\n// \n// Copyright (c) 2007 The Trustees of Indiana University.\n// 2008 Dresden University of Technology and the Trustees of Indiana University.\n// 2010 SimuNova UG (haftungsbeschränkt), www.simunova.com.\n// All rights reserved.\n// Authors: Peter Gottschling and Andrew Lumsdaine\n// \n// This file is part of the Matrix Template Library\n// \n// See also license.mtl.txt in the distribution.\n\n#ifndef MATH_IDENTITY_INCLUDE\n#define MATH_IDENTITY_INCLUDE\n\n#include \n#include \n#include \n#include \n\n#include \n\nnamespace math {\n\ntemplate \nstruct identity_t {};\n\n// TBD: Do we the case that the return type is different? Using std::unary_function?\n\n// Additive identity of Element type is by default a converted 0\n// However, for vectors one needs to know the dimension\n// (and in parallel eventually also the distribution).\n// Therefore, an element is passed as reference.\n// It is strongly recommended to specialize this functor\n// for better efficiency.\ntemplate \nstruct identity_t< add, Element > \n : public std::binary_function, Element, Element>\n{ \n Element operator() (const add&, const Element& ref) const\n {\n\tElement tmp(ref);\n\ttmp= 0;\n\treturn tmp;\n }\n};\n\ntemplate <>\nstruct identity_t< add, std::string > \n : public std::binary_function, std::string, std::string>\n{ \n std::string operator() (const add&, const std::string&) const\n {\n\treturn std::string();\n }\n};\n\n// Multiplicative identity of Element type is by default a converted 1\n// Same comments as above.\n// In contrast to additive identity, this default more likely to be wrong (e.g. matrices with all 1s)\ntemplate \nstruct identity_t< mult, Element > \n : public std::binary_function, Element, Element>\n{ \n Element operator() (const mult&, const Element& ref) const\n {\n\tElement tmp(ref);\n\ttmp= 1;\n\treturn tmp;\n }\n};\n\n\n// Identity of max is minimal representable value, for standard types defined in numeric_limits\ntemplate \nstruct identity_t< max, Element > \n : public std::binary_function, Element, Element>\n{ \n Element operator() (const max&, const Element& ) const\n {\n\tusing std::numeric_limits;\n\treturn numeric_limits::min();\n }\n};\n\ntemplate <>\nstruct identity_t< max, float > \n : public std::binary_function, float, float>\n{ \n float operator() (const max&, const float& ) const\n {\n\tusing std::numeric_limits;\n\treturn -numeric_limits::max();\n }\n};\n\ntemplate <>\nstruct identity_t< max, double > \n : public std::binary_function, double, double>\n{ \n double operator() (const max&, const double& ) const\n {\n\tusing std::numeric_limits;\n\treturn -numeric_limits::max();\n }\n};\n\n\n#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS\n \ntemplate <>\nstruct identity_t< max, long double > \n : public std::binary_function, long double, long double>\n{ \n long double operator() (const max&, const long double& ) const\n {\n\tusing std::numeric_limits;\n\treturn -numeric_limits::max();\n }\n};\n\n#endif\n\n\n\n// Identity of min is maximal representable value, for standard types defined in numeric_limits\ntemplate \nstruct identity_t< min, Element > \n : public std::binary_function, Element, Element>\n{ \n Element operator() (const min&, const Element& ) const\n {\n\tusing std::numeric_limits;\n\treturn numeric_limits::max();\n }\n};\n\n// Identity of bit-wise and\ntemplate \nstruct identity_t< bitwise_and, Element > \n : public std::binary_function, Element, Element>\n{ \n Element operator() (const bitwise_and&, const Element&) const\n {\n\treturn 0;\n }\n};\n\n// Identity of bit-wise or\ntemplate \nstruct identity_t< bitwise_or, Element > \n : public std::binary_function, Element, Element>\n{ \n Element operator() (const bitwise_or&, const Element&) const\n {\n\treturn 0 - 1;\n }\n};\n\n#if 0 // ambiguous specialization\ntemplate {#SquareRoot, #DiagonalCovarianceMatrix, #CovarianceMatrix}.\n *\n * This method is used to determine the best suitable representation\n * for conversion. It is recommanded to put the diagonal forms at the\n * beginning of the initialization-list. Diagonal forms can be converted\n * most efficiently other representations.\n */\n template \n Attribute select_first_representation(\n const std::array& representations\n ) const noexcept\n {\n for (auto& rep: representations) if (!is_dirty(rep)) return rep;\n return Attributes;\n }\n /** \\endcond */\n\nprotected:\n /** \\cond internal */\n Variate mean_; /**< \\brief first moment vector */\n mutable SecondMoment covariance_; /**< \\brief cov. form */\n mutable SecondMoment precision_; /**< \\brief cov. inverse form */\n mutable SecondMoment square_root_; /**< \\brief cov. square root form */\n mutable bool full_rank_; /**< \\brief full rank flag */\n mutable Real log_norm_; /**< \\brief log normalizing constant */\n mutable Real determinant_; /**< \\brief determinant of covariance */\n mutable FlagArray dirty_; /**< \\brief data validity flags */\n /** \\endcond */\n};\n\n/** \\} */\n\n}\n", "meta": {"hexsha": "d1503ea803d1b355c1b9c93821d9e273d14caa3d", "size": 23742, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/fl/distribution/gaussian.hpp", "max_stars_repo_name": "catree/fl", "max_stars_repo_head_hexsha": "de28c2eef13105b820332b99cef1941cbc6d96a3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/fl/distribution/gaussian.hpp", "max_issues_repo_name": "catree/fl", "max_issues_repo_head_hexsha": "de28c2eef13105b820332b99cef1941cbc6d96a3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/fl/distribution/gaussian.hpp", "max_forks_repo_name": "catree/fl", "max_forks_repo_head_hexsha": "de28c2eef13105b820332b99cef1941cbc6d96a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-11-20T14:05:50.000Z", "max_forks_repo_forks_event_max_datetime": "2018-11-20T14:05:50.000Z", "avg_line_length": 30.2445859873, "max_line_length": 82, "alphanum_fraction": 0.5862185157, "num_tokens": 4894, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6619228758499941, "lm_q2_score": 0.5273165233795671, "lm_q1q2_score": 0.34904286963862374}} {"text": "#include \n#include \n\n#include \n\nextern \"C\" void externalForces(double t, double *f, unsigned int size_z, double *z)\n{\n f[0]=0;\n f[1]=0;\n f[2]=0;\n\n}\n\nextern \"C\" void externalMoment(double t,double *m, unsigned int size_z, double *z)\n{\n m[0]=0;\n m[1]=0;\n m[2]=0;\n}\n\nextern \"C\" void fInt_beam1(double t, double *q, double *v, double *f, unsigned int size_z, double *z)\n{\n // printf(\"fInt_beam1\\n\");\n // printf(\"q[0] = %e\\t q[1] = %e\\t, q[2]=%e\\n\",q[0],q[1],q[2]);\n f[0]=1e4*q[0];\n f[1]=0.0;\n f[2]=1e4*q[2];\n // printf(\"f[0] = %e\\t f[1] = %e\\t, f[2]=%e\\n\",f[0],f[1],f[2]);\n\n}\nextern \"C\" void jacobianFIntq_beam1(double t, double *q, double *v, double *jac, unsigned int size_z, double *z)\n{\n for(int i =0; i < 3; i++)\n {\n for(int j=0; j<7; j++)\n jac[i+j*3]=0.0;\n }\n jac[0+0*3]=1e4;\n jac[2+2*3]=1e4;\n}\n\nextern \"C\" void jacobianFIntv_beam1(double t, double *q, double *v, double *jac, unsigned int size_z, double *z)\n{\n for(int i =0; i < 3; i++)\n {\n for(int j=0; j< 6; j++)\n jac[i+j*3]=0.0;\n }\n}\n\n\nextern \"C\" void mInt_beam1(double t, double *q, double *v, double *m, unsigned int size_z, double *z)\n{\n // printf(\"mInt_beam1 :\\n\");\n\n // Simple torsional spring around y axis\n // printf(\"q[0] = %e\\n\", q[0]);\n // printf(\"q[1] = %e\\n\", q[1]);\n // printf(\"q[2] = %e\\n\", q[2]);\n // printf(\"q[3] = %e\\n\", q[3]);\n // printf(\"q[4] = %e\\n\", q[4]);\n // printf(\"q[5] = %e\\n\", q[5]);\n // printf(\"q[6] = %e\\n\", q[6]);\n\n double angle = 2*asin(q[5]);\n // printf(\"angle = %e\\n\", angle);\n m[0]=0.0;\n m[1]=1e3*(angle-1.0);\n m[2]=0.0;\n // printf(\"m[0] = %e\\t m[1] = %e\\t, m[2]=%e\\n\",m[0],m[1],m[2]);\n}\n\nextern \"C\" void jacobianMIntq_beam1(double t, double *q, double *v, double *jac, unsigned int size_z, double *z)\n{\n // printf(\"jacobianMIntq_beam1:\\n \");\n for(int i =0; i < 3; i++)\n {\n for(int j=0; j<7; j++)\n jac[i+j*3]=0.0;\n }\n // printf(\"q[0] = %e\\n\", q[0]);\n // printf(\"q[1] = %e\\n\", q[1]);\n // printf(\"q[2] = %e\\n\", q[2]);\n // printf(\"q[3] = %e\\n\", q[3]);\n // printf(\"q[4] = %e\\n\", q[4]);\n // printf(\"q[5] = %e\\n\", q[5]);\n // printf(\"q[6] = %e\\n\", q[6]);\n\n // double angle = 2*asin(q[5]);\n\n // printf(\"angle = %e\\n\", angle);\n jac[1+5*3]=1e3 * 2.0 / sqrt(1 - q[5]*q[5]) ;\n //printf(\"jac[3+3*3] = %e\\n\", jac[3+3*3]);\n // printf(\"[(\");\n // for (int i =0; i < 3; i++)\n // {\n // for (int j=0; j<7; j++) printf(\"%e,\\t\",jac[i+j*3]);\n // printf(\"\\n\");\n // }\n // printf(\")]\\n\");\n // // Computation by finite difference\n // double epsilon = 1e-8;\n // double vector[7];\n // double m1[3],m2[3];\n\n // for (int j =0; j < 7; j++)\n // {\n // for (int k =0; k < 7; k++) vector[k] =q[k];\n // vector[j] += epsilon;\n // mInt_beam1(t, q, v, m1, size_z, z);\n // mInt_beam1(t, vector, v, m2, size_z, z);\n // jac[0+j*3]=(m2[0]-m1[0])/epsilon ;\n // jac[1+j*3]=(m2[1]-m1[1])/epsilon ;\n // jac[2+j*3]=(m2[2]-m1[2])/epsilon ;\n // }\n\n // for (int i =0; i < 3; i++)\n // {\n // for (int j=0; j<7; j++) printf(\"%e\\t\",jac[i+j*3]);\n // printf(\"\\n\");\n // }\n\n}\n\n\n\n\nextern \"C\" void jacobianMIntv_beam1(double t, double *q, double *v, double *jac, unsigned int size_z, double *z)\n{\n for(int i =0; i < 3; i++)\n {\n for(int j=0; j< 6; j++)\n jac[i+j*3]=0.0;\n }\n}\n", "meta": {"hexsha": "e8221cd5e4508cd09462e4d9a8180fb0ab7fa043", "size": 3281, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/mechanics/JointsTestsWithInternalForces/SimplePlugin/SimplePlugin.cpp", "max_stars_repo_name": "vacary/siconos-tutorials", "max_stars_repo_head_hexsha": "93c0158321077a313692ed52fed69ff3c256ae32", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2017-01-12T23:09:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-20T17:03:58.000Z", "max_issues_repo_path": "examples/mechanics/JointsTestsWithInternalForces/SimplePlugin/SimplePlugin.cpp", "max_issues_repo_name": "vacary/siconos-tutorials", "max_issues_repo_head_hexsha": "93c0158321077a313692ed52fed69ff3c256ae32", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2019-01-14T13:44:51.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-17T13:57:27.000Z", "max_forks_repo_path": "examples/mechanics/JointsTestsWithInternalForces/SimplePlugin/SimplePlugin.cpp", "max_forks_repo_name": "vacary/siconos-tutorials", "max_forks_repo_head_hexsha": "93c0158321077a313692ed52fed69ff3c256ae32", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-10-22T13:30:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-06T10:19:57.000Z", "avg_line_length": 24.125, "max_line_length": 112, "alphanum_fraction": 0.4937519049, "num_tokens": 1437, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6926419958239131, "lm_q2_score": 0.5039061705290805, "lm_q1q2_score": 0.3490265756632474}} {"text": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n\n#include \"Simulator.hpp\"\n#include \"QFRSimulator.hpp\"\n#include \"GroverSimulator.hpp\"\n#include \"ShorFastSimulator.hpp\"\n#include \"ShorSimulator.hpp\"\n\n\nint main(int argc, char** argv) {\n namespace po = boost::program_options;\n unsigned long long seed;\n\n po::options_description description(\"JKQ DDSIM by https://iic.jku.at/eda/ -- Allowed options\");\n description.add_options()\n (\"help,h\", \"produce help message\")\n (\"seed\", po::value(&seed)->default_value(0), \"seed for random number generator (default zero is possibly directly used as seed!)\")\n (\"shots\", po::value()->default_value(0), \"number of measurements (if the algorithm does not contain non-unitary gates, weak simulation is used)\")\n (\"display_vector\", \"display the state vector\")\n (\"ps\", \"print simulation stats (applied gates, sim. time, and maximal size of the DD)\")\n (\"verbose\", \"Causes some simulators to print additional information to STDERR\")\n (\"benchmark\", \"print simulation stats in a single CSV style line (overrides --ps and suppresses most other output, please don't rely on the format across versions)\")\n\n (\"simulate_file\", po::value(), \"simulate a quantum circuit given by file (detection by the file extension)\")\n (\"simulate_qft\", po::value(), \"simulate Quantum Fourier Transform for given number of qubits\")\n (\"simulate_ghz\", po::value(), \"simulate state preparation of GHZ state for given number of qubits\")\n (\"step_fidelity\", po::value()->default_value(1.0), \"target fidelity for each approximation run (>=1 = disable approximation)\")\n (\"steps\", po::value()->default_value(1), \"number of approximation steps\")\n (\"initial_reorder\", po::value()->default_value(0), \"Try to find a good initial variable order (0=None, 1=Most affected qubits to the top, 2=Most affected targets to the top)\")\n (\"dynamic_reorder\", po::value()->default_value(0), \"Apply reordering strategy during simulation (0=None, 1=Sifting, 2=Move2Top)\")\n (\"post_reorder\", po::value()->default_value(0), \"Apply a reordering strategy after simulation (0=None, 1=Sifting)\")\n\n (\"simulate_grover\", po::value(), \"simulate Grover's search for given number of qubits with random oracle\")\n (\"simulate_grover_emulated\", po::value(), \"simulate Grover's search for given number of qubits with random oracle and emulation\")\n (\"simulate_grover_oracle_emulated\", po::value(), \"simulate Grover's search for given number of qubits with given oracle and emulation\")\n\n (\"simulate_shor\", po::value(), \"simulate Shor's algorithm factoring this number\")\n (\"simulate_shor_coprime\", po::value()->default_value(0), \"coprime number to use with Shor's algorithm (zero randomly generates a coprime)\")\n (\"simulate_shor_no_emulation\", \"Force Shor simulator to do modular exponentiation instead of using emulation (you'll usually want emulation)\")\n\n (\"simulate_fast_shor\", po::value(), \"simulate Shor's algorithm factoring this number with intermediate measurements\")\n (\"simulate_fast_shor_coprime\", po::value()->default_value(0), \"coprime number to use with Shor's algorithm (zero randomly generates a coprime)\")\n ;\n po::variables_map vm;\n try {\n po::store(po::parse_command_line(argc, argv, description), vm);\n\n if (vm.count(\"help\")) {\n std::cout << description;\n return 0;\n }\n po::notify(vm);\n } catch (const po::error &e) {\n std::cerr << \"[ERROR] \" << e.what() << \"! Try option '--help' for available commandline options.\\n\";\n std::exit(1);\n }\n\n std::unique_ptr quantumComputation;\n std::unique_ptr ddsim{nullptr};\n\n if (vm.count(\"simulate_file\")) {\n const std::string fname = vm[\"simulate_file\"].as();\n \tquantumComputation = std::make_unique(fname);\n ddsim = std::make_unique(quantumComputation,\n vm[\"steps\"].as(), vm[\"step_fidelity\"].as(),\n vm[\"initial_reorder\"].as(), vm[\"dynamic_reorder\"].as(), vm[\"post_reorder\"].as(),\n seed);\n } else if (vm.count(\"simulate_qft\")) {\n\t const unsigned int n_qubits = vm[\"simulate_qft\"].as();\n\t quantumComputation = std::make_unique(n_qubits);\n ddsim = std::make_unique(quantumComputation,\n vm[\"steps\"].as(), vm[\"step_fidelity\"].as(),\n vm[\"initial_reorder\"].as(), vm[\"dynamic_reorder\"].as(), vm[\"post_reorder\"].as(),\n seed);\n } else if (vm.count(\"simulate_fast_shor\")) {\n const unsigned int composite_number = vm[\"simulate_fast_shor\"].as();\n const unsigned int coprime = vm[\"simulate_fast_shor_coprime\"].as();\n if (seed == 0) {\n ddsim = std::make_unique(composite_number, coprime, vm.count(\"verbose\") > 0);\n } else {\n ddsim = std::make_unique(composite_number, coprime, seed, vm.count(\"verbose\") > 0);\n }\n } else if (vm.count(\"simulate_shor\")) {\n const unsigned int composite_number = vm[\"simulate_shor\"].as();\n const unsigned int coprime = vm[\"simulate_shor_coprime\"].as();\n if (seed == 0) {\n ddsim = std::make_unique(composite_number, coprime, vm.count(\"verbose\") > 0);\n } else {\n ddsim = std::make_unique(composite_number, coprime, seed, vm.count(\"verbose\") > 0);\n }\n } else if (vm.count(\"simulate_grover\")) {\n const unsigned int n_qubits = vm[\"simulate_grover\"].as();\n quantumComputation = std::make_unique(n_qubits, seed);\n ddsim = std::make_unique(quantumComputation,\n vm[\"steps\"].as(), vm[\"step_fidelity\"].as(),\n vm[\"initial_reorder\"].as(), vm[\"dynamic_reorder\"].as(), vm[\"post_reorder\"].as(),\n seed);\n } else if (vm.count(\"simulate_grover_emulated\")) {\n ddsim = std::make_unique(vm[\"simulate_grover_emulated\"].as(), seed);\n } else if (vm.count(\"simulate_grover_oracle_emulated\")) {\n ddsim = std::make_unique(vm[\"simulate_grover_oracle_emulated\"].as(), seed);\n } else if (vm.count(\"simulate_ghz\")) {\n\t const unsigned int n_qubits = vm[\"simulate_ghz\"].as();\n\t quantumComputation = std::make_unique(n_qubits);\n ddsim = std::make_unique(quantumComputation,\n vm[\"steps\"].as(), vm[\"step_fidelity\"].as(),\n vm[\"initial_reorder\"].as(), vm[\"dynamic_reorder\"].as(), vm[\"post_reorder\"].as(),\n seed);\n } else {\n std::cerr << \"Did not find anything to simulate. See help below.\\n\"\n << description << \"\\n\";\n return 1;\n }\n\n if (quantumComputation && quantumComputation->getNqubits() > dd::MAXN) {\n std::cerr << \"Quantum computation contains to many qubits (limit is set to \" << dd::MAXN << \"). See documentation for details.\\n\";\n std::exit(1);\n }\n\n auto t1 = std::chrono::high_resolution_clock::now();\n auto m = ddsim->Simulate(vm[\"shots\"].as());\n auto t2 = std::chrono::high_resolution_clock::now();\n\n std::chrono::duration duration_simulation = t2-t1;\n\n if (vm.count(\"benchmark\")) {\n auto more_info = ddsim->AdditionalStatistics();\n std::cout << ddsim->getName() << \", \"\n << ddsim->getNumberOfQubits() << \", \"\n //<< vm[\"approximate\"].as() << \", \"\n << std::fixed << duration_simulation.count() << std::defaultfloat << \", \"\n //<< more_info[\"approximation_runs\"] << \",\"\n //<< more_info[\"final_fidelity\"] << \", \"\n << more_info[\"coprime_a\"] << \", \"\n << more_info[\"sim_result\"] << \", \"\n << more_info[\"polr_result\"] << \", \"\n << ddsim->getSeed() << \", \"\n << ddsim->getNumberOfOps() << \", \"\n << ddsim->getMaxNodeCount()\n << \"\\n\";\n return 0;\n }\n\n std::cout << \"{\\n\";\n\n if (!m.empty()) {\n std::cout << \" \\\"measurements\\\": {\";\n bool first_element = true;\n for(const auto& element : m)\n {\n std::cout << (first_element ? \"\" : \",\") << \"\\n \\\"\" << element.first << \"\\\": \" << element.second;\n first_element = false;\n }\n std::cout << \"\\n },\\n\";\n }\n if (vm.count(\"display_vector\")) {\n std::cout << \" \\\"state_vector\\\": [\";\n\n bool first_element = true;\n unsigned long long non_zero_entries = 0;\n for(const auto& element : ddsim->getVector()) {\n if (element.r != 0 || element.i != 0) {\n non_zero_entries++;\n std::cout << (first_element ? \"\" : \",\") << \"\\n \" << std::showpos << element.r << element.i << \"i\" << std::noshowpos;\n } else {\n std::cout << (first_element ? \"\" : \",\") << \"\\n 0\";\n }\n first_element = false;\n }\n std::cout << \"\\n ],\\n\";\n std::cout << \" \\\"non_zero_entries\\\": \" << non_zero_entries << \",\\n\";\n }\n\n if (vm.count(\"ps\")) {\n std::cout << \" \\\"statistics\\\": {\\n\"\n << \" \\\"simulation_time\\\": \" << std::fixed << duration_simulation.count() << std::defaultfloat << \",\\n\"\n << \" \\\"benchmark\\\": \\\"\" << ddsim->getName() << \"\\\",\\n\"\n << \" \\\"shots\\\": \" << vm[\"shots\"].as() << \",\\n\"\n << \" \\\"distinct_results\\\": \" << m.size() << \",\\n\"\n << \" \\\"n_qubits\\\": \" << ddsim->getNumberOfQubits() << \",\\n\"\n << \" \\\"applied_gates\\\": \" << ddsim->getNumberOfOps() << \",\\n\"\n << \" \\\"max_nodes\\\": \" << ddsim->getMaxNodeCount() << \",\\n\"\n ;\n for(const auto& item : ddsim->AdditionalStatistics()) {\n std::cout << \" \\\"\" << item.first << \"\\\": \\\"\" << item.second << \"\\\",\\n\";\n }\n std::cout << \" \\\"seed\\\": \" << ddsim->getSeed() << \"\\n\"\n << \" },\\n\";\n }\n std::cout << \" \\\"dummy\\\": 0\\n}\\n\"; // trailing element to make json printout easier\n}\n", "meta": {"hexsha": "4d3e5fe8f33a3a656d8e6493c11f367e5d53fb94", "size": 11429, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "apps/simple.cpp", "max_stars_repo_name": "Tonanguyxiro/ddsim", "max_stars_repo_head_hexsha": "ff6d8afba6e72f4795394688872a9081f871d320", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-03-05T09:17:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-05T09:17:39.000Z", "max_issues_repo_path": "apps/simple.cpp", "max_issues_repo_name": "Tonanguyxiro/ddsim", "max_issues_repo_head_hexsha": "ff6d8afba6e72f4795394688872a9081f871d320", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "apps/simple.cpp", "max_forks_repo_name": "Tonanguyxiro/ddsim", "max_forks_repo_head_hexsha": "ff6d8afba6e72f4795394688872a9081f871d320", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 56.8606965174, "max_line_length": 192, "alphanum_fraction": 0.5661037711, "num_tokens": 2737, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5964331462646254, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.3489737222844969}} {"text": "/**\n * Copyright (c) 2018, University Osnabrück\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * * Neither the name of the University Osnabrück nor the\n * names of its contributors may be used to endorse or promote products\n * derived from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL University Osnabrück BE LIABLE FOR ANY\n * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n/*\n * Matrix.hpp\n *\n * @date 26.08.2008\n * @author Thomas Wiemann (twiemann@uos.de)\n */\n\n#ifndef LVR2_MATRIX_H_\n#define LVR2_MATRIX_H_\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#define _USE_MATH_DEFINES\n#include \n\n#include \n\n#ifndef M_PI\n#define M_PI 3.141592654\n#endif\nusing namespace std;\n\nnamespace lvr2\n{\n\n/**\n * @brief\tA 4x4 matrix class implementation for use with the provided\n * \t\t\tvertex types.\n */\ntemplate\nclass Matrix4 {\npublic:\n\n using ValueType = typename BaseVecT::CoordType;\n\n\t/**\n\t * @brief \tDefault constructor. Initializes a identity matrix.\n\t */\n\tMatrix4()\n\t{\n\t\tfor(int i = 0; i < 16; i++) m[i] = 0;\n\t\tm[0] = m[5] = m[10] = m[15] = 1;\n\t}\n\n\t/**\n\t * @brief\tInitializes a matrix wit the given data array. Ensure\n\t * \t\t\tthat the array has exactly 16 fields.\n\t */\n\ttemplate\n\tMatrix4(T* matrix)\n\t{\n\t\tfor(int i = 0; i < 16; i++) m[i] = matrix[i];\n\t}\n\n\t/**\n\t * @brief \tCopy constructor.\n\t */\n\ttemplate\n\tMatrix4(const Matrix4& other)\n\t{\n\t\tfor(int i = 0; i < 16; i++) m[i] = other[i];\n\t}\n\n\t/**\n\t * @brief\tConstructs a matrix from given axis and angle. Trys to\n\t * \t\t\tavoid a gimbal lock.\n\t */\n\ttemplate\n\tMatrix4(T axis, ValueType angle)\n\t{\n\t\t// Check for gimbal lock\n\t\tif(fabs(angle) < 0.0001){\n\n\t\t\tbool invert_z = axis.z < 0;\n\n\t\t\t//Angle to yz-plane\n\t\t\tfloat pitch = atan2(axis.z, axis.x) - M_PI_2;\n\t\t\tif(pitch < 0.0f) pitch += 2.0f * M_PI;\n\n\t\t\tif(axis.x == 0.0f && axis.z == 0.0) pitch = 0.0f;\n\n\t\t\t//Transform axis into yz-plane\n\t\t\taxis.x = axis.x * cos(pitch) + axis.z * sin(pitch);\n\t\t\taxis.z = -axis.x * sin(pitch) + axis.z * cos(pitch);\n\n\t\t\t//Angle to y-Axis\n\t\t\tfloat yaw = atan2(axis.y, axis.z);\n\t\t\tif(yaw < 0) yaw += 2 * M_PI;\n\n\t\t\tMatrix4 m1, m2, m3;\n\n\t\t\tif(invert_z) yaw = -yaw;\n\n\t\t\tcout << \"YAW: \" << yaw << \" PITCH: \" << pitch << endl;\n\n\t\t\tif(fabs(yaw) > 0.0001){\n\t\t\t\tm2 = Matrix4(T(1.0, 0.0, 0.0), yaw);\n\t\t\t\tm3 = m3 * m2;\n\t\t\t}\n\n\t\t\tif(fabs(pitch) > 0.0001){\n\t\t\t\tm1 = Matrix4(T(0.0, 1.0, 0.0), pitch);\n\t\t\t\tm3 = m3 * m1;\n\t\t\t}\n\n\t\t\tfor(int i = 0; i < 16; i++) m[i] = m3[i];\n\n\t\t} else {\n\t\t\tfloat c = cos(angle);\n\t\t\tfloat s = sin(angle);\n\t\t\tfloat t = 1.0f - c;\n\t\t\tfloat tmp1, tmp2;\n\n\t\t\t// Normalize axis\n\t\t\tNormal a(axis);\n\n\t\t\tm[ 0] = c + a.x * a.x * t;\n\t\t\tm[ 5] = c + a.y * a.y * t;\n\t\t\tm[10] = c + a.z * a.z * t;\n\n\t\t\ttmp1 = a.x * a.y * t;\n\t\t\ttmp2 = a.z * s;\n\t\t\tm[ 4] = tmp1 + tmp2;\n\t\t\tm[ 1] = tmp1 - tmp2;\n\n\t\t\ttmp1 = a.x * a.z * t;\n\t\t\ttmp2 = a.y * s;\n\t\t\tm[ 8] = tmp1 - tmp2;\n\t\t\tm[ 2] = tmp1 + tmp2;\n\n\t\t\ttmp1 = a.y * a.z * t;\n\t\t\ttmp2 = a.x * s;\n\t\t\tm[ 9] = tmp1 + tmp2;\n\t\t\tm[ 6] = tmp1 - tmp2;\n\n\t\t\tm[ 3] = m[ 7] = m[11] = 0.0;\n\t\t\tm[12] = m[13] = m[14] = 0.0;\n\t\t\tm[15] = 1.0;\n\t\t}\n\t}\n\n\ttemplate\n\tMatrix4(const T &position, const T &angles)\n\t{\n\t\tfloat sx = sin(angles[0]);\n\t\tfloat cx = cos(angles[0]);\n\t\tfloat sy = sin(angles[1]);\n\t\tfloat cy = cos(angles[1]);\n\t\tfloat sz = sin(angles[2]);\n\t\tfloat cz = cos(angles[2]);\n\n\t\tm[0] = cy*cz;\n\t\tm[1] = sx*sy*cz + cx*sz;\n\t\tm[2] = -cx*sy*cz + sx*sz;\n\t\tm[3] = 0.0;\n\t\tm[4] = -cy*sz;\n\t\tm[5] = -sx*sy*sz + cx*cz;\n\t\tm[6] = cx*sy*sz + sx*cz;\n\t\tm[7] = 0.0;\n\t\tm[8] = sy;\n\t\tm[9] = -sx*cy;\n\t\tm[10] = cx*cy;\n\n\t\tm[11] = 0.0;\n\n\t\tm[12] = position[0];\n\t\tm[13] = position[1];\n\t\tm[14] = position[2];\n\t\tm[15] = 1;\n\t}\n\n\tMatrix4(string filename);\n\n\t~Matrix4()\n\t{\n\n\t}\n\n Matrix4& operator=(const Eigen::Matrix4d& mat)\n {\n m[0] = mat(0, 0);\n m[1] = mat(0, 1);\n m[2] = mat(0, 2);\n m[3] = mat(0, 3);\n\n m[4] = mat(1, 0);\n m[5] = mat(1, 1);\n m[6] = mat(1, 2);\n m[7] = mat(1, 3);\n\n m[8] = mat(2, 0);\n m[9] = mat(2, 1);\n m[10] = mat(2, 2);\n m[11] = mat(2, 3);\n\n m[12] = mat(3, 0);\n m[13] = mat(3, 1);\n m[14] = mat(3, 2);\n m[15] = mat(3, 3);\n\n return *this;\n }\n\n\t/**\n\t * @brief\tScales the matrix elemnts by the given factor\n\t */\n\tMatrix4 operator*(const ValueType &scale) const\n\t{\n\t\tValueType new_matrix[16];\n\t\tfor(int i = 0; i < 16; i++){\n\t\t\tnew_matrix[i] = m[i] * scale;\n\t\t}\n\t\treturn Matrix4(new_matrix);\n\t}\n\n\t/**\n\t * @brief\tMatrix-Matrix multiplication. Returns the new\n\t * \t\t\tmatrix\n\t */\n\ttemplate\n\tMatrix4 operator*(const Matrix4 &other) const\n\t{\n\t\tValueType new_matrix[16];\n\t\tnew_matrix[ 0] = m[ 0] * other[ 0] + m[ 4] * other[ 1] + m[ 8] * other[ 2] + m[12] * other[ 3];\n\t\tnew_matrix[ 1] = m[ 1] * other[ 0] + m[ 5] * other[ 1] + m[ 9] * other[ 2] + m[13] * other[ 3];\n\t\tnew_matrix[ 2] = m[ 2] * other[ 0] + m[ 6] * other[ 1] + m[10] * other[ 2] + m[14] * other[ 3];\n\t\tnew_matrix[ 3] = m[ 3] * other[ 0] + m[ 7] * other[ 1] + m[11] * other[ 2] + m[15] * other[ 3];\n\t\tnew_matrix[ 4] = m[ 0] * other[ 4] + m[ 4] * other[ 5] + m[ 8] * other[ 6] + m[12] * other[ 7];\n\t\tnew_matrix[ 5] = m[ 1] * other[ 4] + m[ 5] * other[ 5] + m[ 9] * other[ 6] + m[13] * other[ 7];\n\t\tnew_matrix[ 6] = m[ 2] * other[ 4] + m[ 6] * other[ 5] + m[10] * other[ 6] + m[14] * other[ 7];\n\t\tnew_matrix[ 7] = m[ 3] * other[ 4] + m[ 7] * other[ 5] + m[11] * other[ 6] + m[15] * other[ 7];\n\t\tnew_matrix[ 8] = m[ 0] * other[ 8] + m[ 4] * other[ 9] + m[ 8] * other[10] + m[12] * other[11];\n\t\tnew_matrix[ 9] = m[ 1] * other[ 8] + m[ 5] * other[ 9] + m[ 9] * other[10] + m[13] * other[11];\n\t\tnew_matrix[10] = m[ 2] * other[ 8] + m[ 6] * other[ 9] + m[10] * other[10] + m[14] * other[11];\n\t\tnew_matrix[11] = m[ 3] * other[ 8] + m[ 7] * other[ 9] + m[11] * other[10] + m[15] * other[11];\n\t\tnew_matrix[12] = m[ 0] * other[12] + m[ 4] * other[13] + m[ 8] * other[14] + m[12] * other[15];\n\t\tnew_matrix[13] = m[ 1] * other[12] + m[ 5] * other[13] + m[ 9] * other[14] + m[13] * other[15];\n\t\tnew_matrix[14] = m[ 2] * other[12] + m[ 6] * other[13] + m[10] * other[14] + m[14] * other[15];\n\t\tnew_matrix[15] = m[ 3] * other[12] + m[ 7] * other[13] + m[11] * other[14] + m[15] * other[15];\n\t\treturn Matrix4(new_matrix);\n\t}\n\n\t/**\n\t * @brief \tMatrix addition operator. Returns a new matrix\n\t *\n\t */\n\ttemplate\n\tMatrix4 operator+(const Matrix4 &other) const\n\t{\n\t\tValueType new_matrix[16];\n\t\tfor(int i = 0; i < 16; i++)\n\t\t{\n\t\t\tnew_matrix[i] = m[i] + other[i];\n\t\t}\n\t\treturn Matrix4(new_matrix);\n\t}\n\n\t/**\n\t * @brief \tMatrix addition operator\n\t */\n\ttemplate\n\tMatrix4 operator+=(const Matrix4 &other)\n\t{\n\t\t//if(other != *this)\n\t\t//{\n\t\t\treturn *this + other;\n\t\t//}\n\t\t//else\n\t\t//{\n\t\t\t//return *this;\n\t\t//}\n\t}\n\n\t/**\n\t * @brief\tMatrix-Matrix multiplication (array based). Mainly\n\t * \t\t\timplemented for compatibility with other math libs.\n\t * \t\t\tensure that the used array has at least 16 elements\n\t * \t\t\tto avoid memory access violations.\n\t */\n\ttemplate\n\tMatrix4 operator*(const T* &other) const\n\t{\n\t\tValueType new_matrix[16];\n\t\tnew_matrix[ 0] = m[ 0] * other[ 0] + m[ 4] * other[ 1] + m[ 8] * other[ 2] + m[12] * other[ 3];\n\t\tnew_matrix[ 1] = m[ 1] * other[ 0] + m[ 5] * other[ 1] + m[ 9] * other[ 2] + m[13] * other[ 3];\n\t\tnew_matrix[ 2] = m[ 2] * other[ 0] + m[ 6] * other[ 1] + m[10] * other[ 2] + m[14] * other[ 3];\n\t\tnew_matrix[ 3] = m[ 3] * other[ 0] + m[ 7] * other[ 1] + m[11] * other[ 2] + m[15] * other[ 3];\n\t\tnew_matrix[ 4] = m[ 0] * other[ 4] + m[ 4] * other[ 5] + m[ 8] * other[ 6] + m[12] * other[ 7];\n\t\tnew_matrix[ 5] = m[ 1] * other[ 4] + m[ 5] * other[ 5] + m[ 9] * other[ 6] + m[13] * other[ 7];\n\t\tnew_matrix[ 6] = m[ 2] * other[ 4] + m[ 6] * other[ 5] + m[10] * other[ 6] + m[14] * other[ 7];\n\t\tnew_matrix[ 7] = m[ 3] * other[ 4] + m[ 7] * other[ 5] + m[11] * other[ 6] + m[15] * other[ 7];\n\t\tnew_matrix[ 8] = m[ 0] * other[ 8] + m[ 4] * other[ 9] + m[ 8] * other[10] + m[12] * other[11];\n\t\tnew_matrix[ 9] = m[ 1] * other[ 8] + m[ 5] * other[ 9] + m[ 9] * other[10] + m[13] * other[11];\n\t\tnew_matrix[10] = m[ 2] * other[ 8] + m[ 6] * other[ 9] + m[10] * other[10] + m[14] * other[11];\n\t\tnew_matrix[11] = m[ 3] * other[ 8] + m[ 7] * other[ 9] + m[11] * other[10] + m[15] * other[11];\n\t\tnew_matrix[12] = m[ 0] * other[12] + m[ 4] * other[13] + m[ 8] * other[14] + m[12] * other[15];\n\t\tnew_matrix[13] = m[ 1] * other[12] + m[ 5] * other[13] + m[ 9] * other[14] + m[13] * other[15];\n\t\tnew_matrix[14] = m[ 2] * other[12] + m[ 6] * other[13] + m[10] * other[14] + m[14] * other[15];\n\t\tnew_matrix[15] = m[ 3] * other[12] + m[ 7] * other[13] + m[11] * other[14] + m[15] * other[15];\n\t\treturn Matrix4(new_matrix);\n\t}\n\n\t/**\n\t * @brief\tMultiplication of Matrix and Vertex types\n\t */\n\ttemplate\n\tT operator*(const T &v) const\n\t{\n using ValType = typename T::CoordType;\n\t\tValType x = m[ 0] * v.x + m[ 4] * v.y + m[8 ] * v.z;\n\t\tValType y = m[ 1] * v.x + m[ 5] * v.y + m[9 ] * v.z;\n\t\tValType z = m[ 2] * v.x + m[ 6] * v.y + m[10] * v.z;\n\n\t\tx = x + m[12];\n\t\ty = y + m[13];\n\t\tz = z + m[14];\n\n\t\treturn T(x, y, z);\n\t}\n\n /**\n * @brief Multiplication of Matrix and Vertex types\n */\n template\n Normal operator*(const Normal &v) const\n {\n T x = m[ 0] * v.x + m[ 4] * v.y + m[8 ] * v.z;\n T y = m[ 1] * v.x + m[ 5] * v.y + m[9 ] * v.z;\n T z = m[ 2] * v.x + m[ 6] * v.y + m[10] * v.z;\n\n return Normal(x, y, z);\n }\n\n\t/**\n\t * @brief\tSets the given index of the Matrix's data field\n\t * \t\t\tto the provided value.\n\t *\n\t * @param\ti\t\tField index of the matrix\n\t * @param\tvalue\tnew value\n\t */\n\tvoid set(int i, ValueType value){m[i] = value;};\n\n\t/**\n\t * @brief\tTransposes the current matrix\n\t */\n\tvoid transpose()\n\t{\n\t\tValueType m_tmp[16];\n\t\tm_tmp[0] = m[0];\n\t\tm_tmp[4] = m[1];\n\t\tm_tmp[8] = m[2];\n\t\tm_tmp[12] = m[3];\n\t\tm_tmp[1] = m[4];\n\t\tm_tmp[5] = m[5];\n\t\tm_tmp[9] = m[6];\n\t\tm_tmp[13] = m[7];\n\t\tm_tmp[2] = m[8];\n\t\tm_tmp[6] = m[9];\n\t\tm_tmp[10] = m[10];\n\t\tm_tmp[14] = m[11];\n\t\tm_tmp[3] = m[12];\n\t\tm_tmp[7] = m[13];\n\t\tm_tmp[11] = m[14];\n\t\tm_tmp[15] = m[15];\n\t\tfor(int i = 0; i < 16; i++) m[i] = m_tmp[i];\n\t}\n\n\t/**\n\t * @brief\tComputes an Euler representation (x, y, z) plus three\n\t * \t\t\trotation values in rad. Rotations are with respect to\n\t * \t\t\tthe x, y, z axes.\n\t */\n\tvoid toPostionAngle(ValueType pose[6])\n\t{\n\t\tif(pose != 0){\n\t\t\tfloat _trX, _trY;\n\t\t\tif(m[0] > 0.0) {\n\t\t\t\tpose[4] = asin(m[8]);\n\t\t\t} else {\n\t\t\t\tpose[4] = (float)M_PI - asin(m[8]);\n\t\t\t}\n\t\t\t// rPosTheta[1] = asin( m[8]); // Calculate Y-axis angle\n\n\t\t\tfloat C = cos( pose[4] );\n\t\t\tif ( fabs( C ) > 0.005 ) { // Gimball lock?\n\t\t\t\t_trX = m[10] / C; // No, so get X-axis angle\n\t\t\t\t_trY = -m[9] / C;\n\t\t\t\tpose[3] = atan2( _trY, _trX );\n\t\t\t\t_trX = m[0] / C; // Get Z-axis angle\n\t\t\t\t_trY = -m[4] / C;\n\t\t\t\tpose[5] = atan2( _trY, _trX );\n\t\t\t} else { // Gimball lock has occurred\n\t\t\t\tpose[3] = 0.0; // Set X-axis angle to zero\n\t\t\t\t_trX = m[5]; //1 // And calculate Z-axis angle\n\t\t\t\t_trY = m[1]; //2\n\t\t\t\tpose[5] = atan2( _trY, _trX );\n\t\t\t}\n\n\t\t\t// cout << pose[3] << \" \" << pose[4] << \" \" << pose[5] << endl;\n\n\t\t\tpose[0] = m[12];\n\t\t\tpose[1] = m[13];\n\t\t\tpose[2] = m[14];\n\t\t}\n\t}\n\n\t/**\n\t * @brief\tLoads matrix values from a given file.\n\t */\n\tvoid loadFromFile(string filename)\n\t{\n\t\tifstream in(filename.c_str());\n\t\tfor(int i = 0; i < 16; i++){\n\t\t\tif(!in.good()){\n cout << \"Warning: Matrix::loadFromFile: File not found or corrupted: \" << filename << endl;\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tin >> m[i];\n\t\t}\n\t}\n\n\t/**\n\t * @brief\tMatrix scaling with self assignment.\n\t */\n\ttemplate\n\tvoid operator*=(const T scale)\n\t{\n\t\t*this = *this * scale;\n\t}\n\n\t/**\n\t * @brief \tMatrix-Matrix multiplication with self assigment.\n\t */\n\ttemplate\n\tvoid operator*=(const Matrix4& other)\n\t{\n\t\t*this = *this * other;\n\t}\n\n\t/**\n\t * @brief\tMatrix-Matrix multiplication (array based). See \\ref{operator*}.\n\t */\n\ttemplate\n\tvoid operator*=(const T* other)\n\t{\n\t\t*this = *this * other;\n\t}\n\n\t/**\n\t * @brief\tReturns the internal data array. Unsafe. Will probably\n\t * \t\t\tremoved in one of the next versions.\n\t */\n\tValueType* getData(){ return m;}\n\n floatArr toFloatArray()\n {\n floatArr a(new float[16]);\n for(int i = 0; i < 16; i++)\n {\n a[i] = m[i];\n }\n return a;\n }\n\n std::vector getVector()\n {\n std::vector tmp(16);\n for(int i = 0; i < 16; i++)\n {\n tmp.push_back(m[i]);\n }\n return tmp;\n }\n\n\t/**\n\t * @brief\tReturns the element at the given index.\n\t */\n\tValueType at(const int i) const;\n\n\t/**\n\t * @brief\tIndexed element (reading) access.\n\t */\n\tValueType operator[](const int index) const\n\t{\n\t /// TODO: Boundary check\n\t return m[index];\n\t}\n\n\n\t/**\n\t * @brief \tWriteable index access\n\t */\n\tValueType& operator[](const int index)\n\t{\n\t\treturn m[index];\n\t}\n\n\t/**\n\t * @brief Returns the matrix's determinant\n\t */\n\tValueType det()\n\t{\n\t ValueType det, result = 0, i = 1.0;\n\t ValueType Msub3[9];\n\t int n;\n\t for ( n = 0; n < 4; n++, i *= -1.0 ) {\n\t submat( Msub3, 0, n );\n\t det = det3( Msub3 );\n\t result += m[n] * det * i;\n\t }\n\t return( result );\n\t}\n\n\tMatrix4 inv(bool& success)\n\t{\n\t Matrix4 Mout;\n\t ValueType mdet = det();\n\t if ( fabs( mdet ) < 0.00000000000005 ) {\n\t cout << \"Error matrix inverting! \" << mdet << endl;\n\t return Mout;\n\t }\n\t ValueType mtemp[9];\n\t int i, j, sign;\n\t for ( i = 0; i < 4; i++ ) {\n\t for ( j = 0; j < 4; j++ ) {\n\t sign = 1 - ( (i +j) % 2 ) * 2;\n\t submat( mtemp, i, j );\n\t Mout[i+j*4] = ( det3( mtemp ) * sign ) / mdet;\n\t }\n\t }\n\t return Mout;\n\t}\n\n\tValueType m[16];\n\nprivate:\n\n /**\n * @brief Returns a sub matrix without row \\ref i and column \\ref j.\n */\n\tvoid submat(ValueType* submat, int i, int j)\n\t{\n\t int di, dj, si, sj;\n\t // loop through 3x3 submatrix\n\t for( di = 0; di < 3; di ++ ) {\n\t for( dj = 0; dj < 3; dj ++ ) {\n\t // map 3x3 element (destination) to 4x4 element (source)\n\t si = di + ( ( di >= i ) ? 1 : 0 );\n\t sj = dj + ( ( dj >= j ) ? 1 : 0 );\n\t // copy element\n\t submat[di * 3 + dj] = m[si * 4 + sj];\n\t }\n\t }\n\t}\n\n\t/**\n\t * @brief Calculates the determinant of a 3x3 matrix\n\t *\n\t * @param M input 3x3 matrix\n\t * @return determinant of input matrix\n\t */\n\tValueType det3(const ValueType *M )\n\t{\n\t ValueType det;\n\t det = (double)( M[0] * ( M[4]*M[8] - M[7]*M[5] )\n\t - M[1] * ( M[3]*M[8] - M[6]*M[5] )\n\t + M[2] * ( M[3]*M[7] - M[6]*M[4] ));\n\t return ( det );\n\t}\n\n\t\n};\n\n/**\n * @brief Output operator for matrices.\n */\ntemplate\ninline ostream& operator<<(ostream& os, const Matrix4 matrix){\n\tos << \"Matrix:\" << endl;\n\tos << fixed;\n\tfor(int i = 0; i < 16; i++){\n\t\tos << setprecision(4) << matrix[i] << \" \";\n\t\tif(i % 4 == 3) os << \" \" << endl;\n\t}\n\tos << endl;\n\treturn os;\n}\n\n} // namespace lvr2\n\n#endif /* MATRIX_H_ */\n", "meta": {"hexsha": "7126e5cc7880e1437306e0d02671b2a911b025c9", "size": 16649, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/lvr2/geometry/Matrix4.hpp", "max_stars_repo_name": "jtpils/lvr2", "max_stars_repo_head_hexsha": "b1010dfcc930d9ae0ff5cfa5c88d0810d65368ce", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-08-07T03:55:27.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-07T03:55:27.000Z", "max_issues_repo_path": "include/lvr2/geometry/Matrix4.hpp", "max_issues_repo_name": "jtpils/lvr2", "max_issues_repo_head_hexsha": "b1010dfcc930d9ae0ff5cfa5c88d0810d65368ce", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/lvr2/geometry/Matrix4.hpp", "max_forks_repo_name": "jtpils/lvr2", "max_forks_repo_head_hexsha": "b1010dfcc930d9ae0ff5cfa5c88d0810d65368ce", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.6384, "max_line_length": 107, "alphanum_fraction": 0.5296414199, "num_tokens": 6349, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7090191460821871, "lm_q2_score": 0.49218813572079556, "lm_q1q2_score": 0.34897081170054206}} {"text": "#include \"scan_material.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \n#include \n\n#include // for nullptr\n#include // for writing as an int32_t and int16_t\n\nusing namespace Constants;\n\n/* Here's main */\nint main(int argc, char* argv[])\n{\n\tstd::time_t tstart = std::time(nullptr);\n\tstd::cout << \"\\t\\t======================================\\n\"\n\t\t<< \"\\t\\t======= scan_material started ========\\n\"\n\t\t<< \"\\t\\t===== \" << std::asctime(std::localtime(&tstart)) \n\t\t<< \"\\t\\t===== on host \" << getenv(\"HOSTNAME\") << \"\\n\"\n\t\t<< \"\\t\\t===== for \" << getenv(\"nimages\") << \" images\\n\"\n\t\t<< \"\\t\\t===== with \" << getenv(\"nfibers\") << \" fibers\\n\"\n\t\t<< \"\\t\\t======================================\\n\" << std::flush;\n\n\tunsigned nthreads = (unsigned)atoi( getenv(\"nthreads\") );\n\tstd::cout << \"Scaling fibers =\\t\";\n\tif (getenv(\"scale_fibers\")){\n\t\tstd::cout << \"yes\\n\";\n\t} else {\n\t\tstd::cout << \"no\\n\";\n\t}\n\tstd::cout << std::flush;\n\n\tScanParams scanparams;\n\tscanparams.nimages(size_t(atoi(getenv(\"nimages\"))));\n\tscanparams.filebase(std::string(getenv(\"filebase\")));\n\tscanparams.calfilebase(std::string(getenv(\"calfilebase\")));\n\n\tstd::vector imagetimes(scanparams.nimages(),0); // for benchmarking the processors\n\n\tscanparams.dalpha((atof(getenv(\"drifting_alpha\")))*pi()/scanparams.nimages());\n\n\tif (scanparams.doublepulse(atoi(getenv(\"doublepulse\")) > 0 )){\n\t\tscanparams.doublepulsedelay(atof( getenv(\"doublepulsedelay\") ) ) ; // this one gets used directly in atomic units\n\t}\n\tscanparams.lambda_0(atof( getenv(\"lambda0\") ));\n\tscanparams.lambda_width( atof( getenv(\"lambda_width\") ));\n\tscanparams.lambda_onoff( atof( getenv(\"lambda_onoff\") ));\n\tscanparams.tspan((atof( getenv(\"tspan\") ) )/fsPau());\n\n\tscanparams.ngroupsteps(atoi( getenv(\"ngroupsteps\") ));\n\tscanparams.groupdelay(atof(getenv(\"groupdelay\")));\n\tscanparams.backdelay(atof(getenv(\"backdelay\")));\n\tscanparams.netalon(atoi(getenv(\"netalon\")));\n\n\n\tscanparams.etalonreflectance(atof(getenv(\"etalon\")));\n\tscanparams.etalondelay(atof(getenv(\"etalondelay\")));\n\tscanparams.interferedelay((double)atof(getenv(\"interferedelay\")));\n\n\tscanparams.chirp(\n\t\t\t( atof( getenv(\"chirp\") ) ) / std::pow(fsPau(),int(2)), // the difference in slopes at omega_low versus omega_high must equal tspan\n\t\t\t( atof( getenv(\"TOD\") ) ) / std::pow(fsPau(),int(3)),\n\t\t\t( atof( getenv(\"FOD\") ) ) / std::pow(fsPau(),int(4)),\n\t\t\t( atof( getenv(\"fifthOD\") ) ) / std::pow(fsPau(),int(5))\n\t\t\t);\n\n\n\tif (scanparams.addchirpnoise(atoi(getenv(\"usechirpnoise\"))>0)){\n\t\tscanparams.initchirpnoise( \n\t\t\t\t( atof( getenv(\"chirpnoise\") ) ) / std::pow(fsPau(),int(2)), \n\t\t\t\t( atof( getenv(\"TODnoise\") ) ) / std::pow(fsPau(),int(3)),\n\t\t\t\t( atof( getenv(\"FODnoise\") ) ) / std::pow(fsPau(),int(4)),\n\t\t\t\t( atof( getenv(\"fifthODnoise\") ) ) / std::pow(fsPau(),int(5))\n\t\t\t\t);\n\t}\n\n\n\n\n\tFiberBundle masterbundle(boost::lexical_cast(atoi(getenv(\"nfibers\"))));\n\tmasterbundle.fiberdiameter(boost::lexical_cast(atof(getenv(\"fiberdiam\"))));\n\tmasterbundle.laserdiameter(boost::lexical_cast(atof(getenv(\"laserdiam\"))));\n\tmasterbundle.xraydiameter(boost::lexical_cast(atof(getenv(\"xraydiam\"))));\n\tmasterbundle.set_fsPmm(boost::lexical_cast(atof(getenv(\"bundle_fsPmm\"))));\n\tmasterbundle.scalePolarCoords();\n\n\tstd::cout << \"\\t\\tshuffle fibers?\\t\";\n\tif (getenv(\"shuffle_fibers\"))\n\t{\n\t\tstd::cout << \"yes\\n\";masterbundle.shuffle_output();\n\t} else {\n\t\tstd::cout << \"no\\n\";\n\t}\n\n\tmasterbundle.Ixray(float(1.));\n\tmasterbundle.Ilaser(float(1.));\n\tstd::string filename = scanparams.filebase() + \"fibermap.out\";\n\tstd::cout << \"fibermap file = \" << filename << std::endl << std::flush;\n\tstd::ofstream mapfile(filename.c_str(),std::ios::out);\n\t//masterbundle.print_mapping(mapfile,double(0.0));\n\tmapfile.close();\n\n\t// file for delay bins\n\tofstream outbins(std::string(scanparams.filebase() + \"delaybins.out\").c_str(),ios::out); \n\tfor (size_t f=0;f(atoi(getenv(\"ncalibdelays\")))\n\t\t\t, boost::lexical_cast(atof(getenv(\"fsWindow\"))));\n\tif (!getenv(\"skipcalibration\"))\n\t{\n\t\tstd::cout << \"\\t\\t############ entering calibration ###########\\n\" << std::flush;\n\t\tcalibration.set_center(boost::lexical_cast(atof(getenv(\"delays_mean\"))));\n\t\tstd::cout << \"\\t\\t====== delays =======\\n\";\n\t\tfor (size_t i = 0 ; i< calibration.get_ndelays(); ++i){\n\t\t\tstd::cout << calibration.get_delay(i) << \" \";\n\t\t}\n\t\tstd::cout << std::endl << std::flush;\n\t}\n\n\n\n\tif (!getenv(\"skipcalibration\"))\n\t{\n\t\t// Setup the shared pulse arrays\n\t\tstd::vector< PulseFreq > calpulsearray(calibration.get_ndelays(),masterpulse);\n\n#pragma omp parallel num_threads(nthreads) default(shared) shared(masterpulse)\n\t\t{ // begin parallel region 1\n\t\t\tsize_t tid = omp_get_thread_num();\n\n\t\t\t// all non-shared objects must be created inside the parallel section for default is shared if defined outside\n\t\t\t// http://pages.tacc.utexas.edu/~eijkhout/pcse/html/omp-data.html\n\t\t\tPulseFreq etalonpulse(masterpulse);\n\t\t\tPulseFreq crossetalonpulse(masterpulse);\n\t\t\tPulseFreq calpulse(masterpulse);\n\t\t\tPulseFreq calcrosspulse(masterpulse);\n\n\t\t\t// initialize with masterpulse/masterresponse\n\t\t\tMatResponse calibresponse(masterresponse);\n\n\n\n#pragma omp for schedule(dynamic) \n\t\t\tfor (size_t d=0;d pulsearray(nfibers,PulseFreq(masterpulse));\n#pragma omp barrier\n\n\t\t\tif (scanparams.addrandomphase(atoi(getenv(\"addrandomphase\"))>0))\n\t\t\t{\n\t\t\t\tmasterpulse.addrandomphase();\n\t\t\t\tstd::string filename = scanparams.filebase() + \"spectralphaseFTpower.dat\";\n\t\t\t\tstd::ofstream outfile(filename.c_str(),std::ios::out);\n\t\t\t\tmasterpulse.print_phase_powerspectrum(outfile);\n\t\t\t\toutfile.close();\n\t\t\t\tfilename = scanparams.filebase() + \"spectralphase.dat\";\n\t\t\t\toutfile.open(filename.c_str(),std::ios::out);\n\t\t\t\tmasterpulse.print_phase(outfile);\n\t\t\t\toutfile.close();\n\t\t\t\tfilename = scanparams.filebase() + \"spectralamp.dat\";\n\t\t\t\toutfile.open(filename.c_str(),std::ios::out);\n\t\t\t\tmasterpulse.print_amp(outfile);\n\t\t\t\toutfile.close();\n\t\t\t}\n\n\n#pragma omp for schedule(dynamic)\n\t\t\tfor (size_t n=0;n noise(scanparams.getchirpnoise());\n\t\t\t\t\t\tpulse.addchirp(noise); \n\t\t\t\t\t\tcrosspulse.addchirp(noise); \n\t\t\t\t\t}\n\n\t\t\t\t\tcrosspulse.delay(scanparams.interferedelay()); // delay in the frequency domain\n\t\t\t\t\tpulse.fft_totime();\n\t\t\t\t\tcrosspulse.fft_totime();\n\n\t\t\t\t\tfor(size_t g=0;g z_laser = parabundle.center_Ilaser();\n\t\t\t\tstd::complex z_xray = parabundle.center_Ixray();\n\t\t\t\tinterferestream << \"#delay for image = \\t\" << t0 \n\t\t\t\t\t<< \"\\n#Ilaser = \\t\" << parabundle.Ilaser()\n\t\t\t\t\t<< \"\\n#Ixray = \\t\" << parabundle.Ixray()\n\t\t\t\t\t<< \"\\n#center laser = \\t\" << z_laser.real() << \"\\t\" << z_laser.imag() \n\t\t\t\t\t<< \"\\n#center xray = \\t\" << z_xray.real() << \"\\t\" << z_xray.imag()\n\t\t\t\t\t<< \"\\n#alpha = \\t\" << parabundle.delay_angle() \n\t\t\t\t\t<< std::endl;\n\t\t\t\tinterferestream << \"#\";\n\t\t\t\tpulsearray[0].printwavelengthbins(&interferestream);\n\t\t\t\tfor (size_t f=0;f(getenv(\"gain\")) * pulsearray[f].maxsignal();\n\t\t\t\t\t\tfor (size_t i=0;i\n#include \n#include \n#include \n#include \"llvm/Support/raw_ostream.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"helper.h\"\n#include \"klee/ExecutionState.h\"\n#include \"klee/Internal/ADT/RNG.h\"\n#include \n#include \"Executor.h\"\n#include \n#include \"klee/klee.h\"\n\n// TODO: use macros in klee.h instead of hard-coded return values.\n\nusing namespace klee;\nusing namespace std;\nusing namespace llvm;\nusing boost::math::binomial;\n\nnamespace klee {\n extern RNG theRNG;\n}\n\nHashTableHandler::HashTableHandler(Executor &_executor)\n: executor(_executor)\n{\n printf(\"new ht handler created!\\n\");\n}\n\nHashTableHandler::HashTableHandler(HashTableHandler &_handler)\n: executor(_handler.executor)\n{\n\n}\n\nHashTableHandler::~HashTableHandler()\n{\n\n}\n\nHashTable::HashTable()\n{\n}\n\nHashTable::HashTable(int _size):\n status(-1),\n size(_size),\n cur_size(0)\n{\n // create an empty table\n LOG(LOG_MASK_HT, \"creating an empty hash table, size=%d\", _size);\n}\n\nHashTable::HashTable(const HashTable &_table):\n status(_table.status),\n size(_table.size),\n cur_size(_table.cur_size),\n dist(_table.dist)\n{\n}\n\nHashTable::~HashTable()\n{\n}\n\nint HashTableHandler::ht_init(ExecutionState &cur, size_t sz)\n{\n LOG(LOG_MASK_HT, \"allocating table size=%ld\", sz);\n cur.table = new HashTable(sz);\n\n // TODO: add deletion of the hash table\n return 0;\n}\n\nint HashTableHandler::ht_get_max(ExecutionState &cur)\n{\n HashTable *t = cur.table;\n int max = 0;\n for (auto x : t->dist) {\n if (x.first > max) {\n max = x.first;\n }\n }\n LOG(LOG_MASK_HT, \"returning max val in ht = %d\", max);\n return max;\n}\n\nint HashTableHandler::ht_access(ExecutionState &cur,\n vector &states,\n vector &rets)\n{\n HashTable *t = cur.table;\n assert(t);\n\n LOG(LOG_MASK_HT, \"accessing table, cur size=%d\", t->cur_size);\n\n // processing the first access\n if (t->cur_size == 0) {\n LOG(LOG_MASK_HT, \"table is empty, can only insert entry, pathprob=%f\",\n cur.getPathProb());\n t->status = GREYBOX_MISS;\n states.push_back(&cur);\n rets.push_back(GREYBOX_MISS);\n return 0;\n }\n\n // TODO: cannot insert to empty if table is full\n assert(t->cur_size < t->size);\n\n // Obtain per-path probabilities\n double probEmpty = 1 - ((double) t->cur_size) / ((double) t->size);\n double probNonEmpty = 1 - probEmpty;\n double probCollision = probNonEmpty * (1.0 / (double) t->size);\n double probHit = probNonEmpty - probCollision;\n assert(probEmpty + probCollision + probHit > 0.99);\n\n LOG(LOG_MASK_HT, \"table not empty, pathprob=%g, empty=%g,hit=%g,col=%g\",\n cur.getPathProb(), probEmpty, probHit, probCollision);\n\n // if we are doing Monte Carlo sampling, just pick up one state\n if (cur.isSample == true) {\n assert(cur.isSampleDone == false);\n\n double r = theRNG.getDouble();\n\n LOG(LOG_MASK_HT, \"r=%f\", r);\n\n // pick up a branch according to per-path prob\n states.push_back(&cur);\n t = states[0]->table;\n if (r < probEmpty) {\n cur.updatePathProb(probEmpty);\n t->status = GREYBOX_MISS;\n rets.push_back(GREYBOX_MISS);\n LOG(LOG_MASK_HT, \"access=empty, pathprob=%f\", cur.getPathProb());\n } else if (probEmpty <= r && r < probEmpty + probCollision) {\n cur.updatePathProb(probCollision);\n t->status = GREYBOX_COL;\n rets.push_back(GREYBOX_COL);\n LOG(LOG_MASK_HT, \"access=col, pathprob=%f\", cur.getPathProb());\n } else {\n cur.updatePathProb(probHit);\n t->status = GREYBOX_HIT;\n rets.push_back(GREYBOX_HIT);\n LOG(LOG_MASK_HT, \"access=hit, pathprob=%f\", cur.getPathProb());\n }\n\n return 0;\n }\n\n // fork three states\n executor.branchTableAccessNoCond(cur, 3, states);\n rets.push_back(GREYBOX_MISS);\n rets.push_back(GREYBOX_HIT);\n rets.push_back(GREYBOX_COL);\n assert(states.size() == 3);\n assert(rets.size() == 3);\n\n // empty prob\n states[0]->updatePathProb(probEmpty);\n // hit prob\n states[1]->updatePathProb(probHit);\n // collision prob\n states[2]->updatePathProb(probCollision);\n\n // empty\n t = states[0]->table;\n t->status = GREYBOX_MISS;\n\n // hit\n t = states[1]->table;\n t->status = GREYBOX_HIT;\n\n // collision\n t = states[2]->table;\n t->status = GREYBOX_COL;\n\n return 0;\n}\n\nint HashTableHandler::ht_check(ExecutionState &cur, int &status)\n{\n ERR(\"not implemented\");\n assert(0);\n return 0;\n}\n\n// Based the previous access result, return a branch for each possible\n// value in the table\nint HashTableHandler::ht_read(ExecutionState &cur,\n vector &states,\n vector &rets)\n{\n HashTable *t = cur.table;\n\n LOG(LOG_MASK_HT, \"reading HT, status=%d, cur_size=%d\", t->status,\n t->cur_size);\n\n // the access misses the table, have to return 0\n if (t->status == GREYBOX_MISS) {\n rets.push_back(HT_READ_FALSE);\n states.push_back(&cur);\n return 0;\n }\n\n // hit or collision\n assert(t->dist.size() > 0);\n executor.branchTableAccessNoCond(cur, t->dist.size(), states);\n\n int i = 0;\n for (auto x : t->dist) {\n rets.push_back(x.first);\n states[i]->updatePathProb(x.second);\n LOG(LOG_MASK_HT, \"read value=%d, prob=%g, pathProb=%g\", x.first,\n x.second, states[i]->getPathProb());\n i ++;\n }\n\n return 0;\n}\n\n// Write val to the table, based on previous access result\n// This API doesn't fork states\nint HashTableHandler::ht_write(ExecutionState &cur, int val)\n{\n HashTable *t = cur.table;\n int num = t->cur_size;\n double p0 = t->dist[0];\n double p1 = t->dist[1];\n\n // empty table, and we just missed the table\n if (num == 0) {\n assert(t->status == GREYBOX_MISS);\n LOG(LOG_MASK_HT, \"writing %d to an empty table\", val);\n if (val == 0) {\n t->dist[0] = 1;\n t->dist[1] = 0;\n } else if (val == 1) {\n t->dist[0] = 0;\n t->dist[1] = 1;\n }\n t->cur_size += 1;\n return 0;\n }\n\n // Table not empty, but we just missed the table\n if (t->status == GREYBOX_MISS) {\n for (auto d: t->dist) {\n if (d.first == val) {\n d.second = (d.second * num + 1) / (num + 1);\n } else {\n d.second = (d.second * num) / (num + 1);\n }\n }\n t->cur_size += 1;\n return 0;\n }\n\n // write 1 to an empty entry\n /*\n if (val == 1) {\n t->dist[0] = (p0 * num) / (num + 1);\n t->dist[1] = 1 - t->dist[0];\n } else if (val == 0) {\n t->dist[0] = (p0 * num + 1) / (num + 1);\n t->dist[1] = 1 - t->dist[0];\n }\n */\n\n\n // Table not empty, and we just hit or collide on an existing entry\n // TODO: only support binary HT\n if (t->dist.size() > 2) {\n t->dump();\n }\n assert(t->dist.size() <= 2);\n if (val == 1) {\n t->dist[0] = p0 * ((p0 * num - 1) / num) + (p0 * p1);\n t->dist[1] = 1 - t->dist[0];\n } else if (val == 0) {\n t->dist[0] = p0 * p0 +\n p1 * (p0 * num + 1) / num;\n t->dist[1] = 1 - t->dist[0];\n }\n\n return 0;\n}\n\nlong long factorial(long number)\n{\n long long ret;\n if (number <= 1)\n\t\tret = 1;\n\telse\n\t\tret = number * factorial(number - 1);\n\n assert(ret > 0);\n\n return ret;\n}\n\nlong long combinator(int n,int m)\n{\n // LOG(LOG_MASK_HT, \"computing C %d %d\", n, m);\n\n int temp;\n\tif (n < m) {\n temp = n;\n\t\tn = m;\n\t\tm = temp;\n }\n\n\tlong long ret = factorial(n) / (factorial(m) * factorial(n - m));\n\n // LOG(LOG_MASK_HT, \"C %d %d = %lld\", n, m, ret);\n\n return ret;\n}\n\n// This API only supports binary HT, e.g., the value must be 0 or 1\ndouble HashTable::test_sum_prob(int sum)\n{\n double p0, p1, ret = 0;\n p0 = dist[0];\n p1 = dist[1];\n\n if (cur_size < sum) {\n return 0;\n }\n\n const double success_fraction = p1;\n int flips = cur_size;\n\n binomial flip(flips, success_fraction);\n\n ret = 1 - cdf(flip, sum - 1);\n\n assert(ret >= 0);\n assert(ret <= 1);\n\n /*\n for (int i=sum; i <= cur_size; i ++) {\n long long c = combinator(i, cur_size);\n }\n */\n\n LOG(LOG_MASK_HT, \"test sum prob=%f for sum>=%d, size=%d, curSize=%d, p0=%f, p1=%f\",\n ret, sum, size, cur_size, p0, p1);\n\n return ret;\n}\n\nint HashTableHandler::ht_test_sum(ExecutionState &cur, int sum,\n vector &states,\n vector &rets)\n{\n // Compute and update outgoing path probabilities.\n double cur_prob = cur.getPathProb();\n\n // Using the CDF of binomial distribution to compute p\n double p = cur.table->test_sum_prob(sum);\n assert(p >= 0 && p <= 1);\n\n // if larger than sum is 0% or 100%\n if (p < 0.0001 || p > 0.9999) {\n LOG(LOG_MASK_HT, \"p=%f, test_sum is determinsitic\", p);\n states.push_back(&cur);\n rets.push_back(p < 0.0001 ? 0 : 1);\n LOG(LOG_MASK_HT, \"continue pcur=%f, test_sum is %s\", cur_prob,\n p > 0.9999 ? \"100%\" : \"0%\");\n return 0;\n }\n\n // if we are doing Monte Carlo sampling, just pick up one state\n if (cur.isSample == true) {\n assert(cur.isSampleDone == false);\n\n double r = theRNG.getDouble();\n\n states.push_back(&cur);\n\n // 10% return 1 (>= sum)\n if (r < p) {\n cur.updatePathProb(p);\n rets.push_back(1);\n }\n // 90% return 0 (<= sum)\n else {\n cur.updatePathProb(1-p);\n rets.push_back(0);\n }\n\n LOG(LOG_MASK_HT, \"test sum returning, path prob=%f\", cur.getPathProb());\n return 0;\n }\n\n // if both possible, need to fork two branches\n executor.branchTableAccessNoCond(cur, 2, states);\n assert(states.size() == 2);\n\n states[0]->updatePathProb(p);\n rets.push_back(1);\n states[1]->updatePathProb(1 - p);\n rets.push_back(0);\n\n LOG(LOG_MASK_HT, \"pcur=%f, p1=%f, p2=%f\", cur.getPathProb(),\n states[0]->getPathProb(), states[1]->getPathProb());\n\n return 0;\n}\n\nint HashTableHandler::ht_add_handler(ExecutionState &state)\n{\n int status = state.table->status;\n // ht_add returns the prob of hitting/missing the hash table,\n // in this handler we don't need that.\n state.table->ht_add(status);\n return 0;\n}\n\n// Add by 1 to each possible entry of HT, based the previous access result\n// previous result is provided by flag, so that this API can be used by\n// cmin_add_to_ht\ndouble HashTable::ht_add(int flag)\n{\n LOG(LOG_MASK_CMIN, \"adding one to hash table, cur_size=%d, flag=%d\",\n cur_size, flag);\n\n double ret;\n // hit\n if (flag) {\n assert(cur_size > 0);\n int largest = 0;\n for (auto const x : dist) {\n if (x.second > 0 && x.first > largest) {\n largest = x.first;\n }\n }\n int v = largest;\n\n if (dist[v] * cur_size > 1) {\n dist[v] = (double)(dist[v] * cur_size - 1) / (double)cur_size;\n } else {\n dist[v] = 0;\n }\n\n dist[v+1] = (double)(dist[v+1] * cur_size + 1) / (double)cur_size;\n\n ret = (double)cur_size / (double)size;\n return ret;\n }\n\n // miss\n ret = ((double)size - (double)cur_size) / (double)size;\n\n if (dist.size() == 0) {\n dist[1] = 1.0;\n } else {\n for (auto x : dist) {\n if (x.first == 1) {\n x.second = (x.second * cur_size + 1) / (cur_size + 1);\n } else {\n x.second = (x.second * cur_size) / (cur_size + 1);\n }\n }\n }\n\n cur_size += 1;\n return ret;\n}\n\nvoid HashTable::dump()\n{\n LOG(LOG_MASK_HT, \"hash table size=%d, cur_size=%d\", size, cur_size);\n for (auto x : dist) {\n LOG(LOG_MASK_HT, \"[v=%d, p=%f]\", x.first, x.second);\n }\n}\n\nint HashTableHandler::ht_read_larger_than(ExecutionState &cur,\n int val,\n vector &states,\n vector &rets)\n{\n HashTable *t = cur.table;\n double larger = t->ht_get_prob_larger_than_after_hit(val);\n if (larger == 0.0) {\n states.push_back(&cur);\n rets.push_back(0);\n LOG(LOG_MASK_HT, \"cannot greater than %d, returning one branch\", val);\n return 0;\n } else if (larger == 1.0) {\n states.push_back(&cur);\n rets.push_back(1);\n LOG(LOG_MASK_HT, \"always greater than %d, returning one branch\", val);\n return 0;\n }\n\n executor.branchTableAccessNoCond(cur, 2, states);\n\n // branch 1: greater than val\n rets.push_back(1);\n states[0]->updatePathProb(larger);\n // branch 2: cmin is not greater than val\n rets.push_back(0);\n states[1]->updatePathProb(1 - larger);\n\n LOG(LOG_MASK_HT, \"greater than %d prob=%g, elseprob=%g\", val,\n larger, 1-larger);\n return 0;\n}\n\n// Get the probability that ht value is greater than val\n// This API assumes that the previous access has hit HT\ndouble HashTable::ht_get_prob_larger_than_after_hit(int val)\n{\n double ret = 0.0;\n\n for (auto x : dist) {\n if (x.first >= val) {\n ret += x.second;\n }\n }\n return ret;\n}\n\n// Get the probability that ht value is greater than val\n// This API doesn't assume that the previous access has hit HT\n// Should be used by CminHandler::cmin_larger_than\ndouble HashTable::ht_get_prob_larger_than(int val)\n{\n double ret = 0.0;\n\n for (auto x : dist) {\n if (x.first >= val) {\n ret += (x.second * (double)cur_size / (double)size);\n }\n }\n return ret;\n}\n\nint HashTable::getMaxValue()\n{\n int ret = 0;\n for (auto e: dist) {\n if (e.second > 0) {\n ret = ret > e.first ? ret : e.first;\n }\n }\n return ret;\n}\n", "meta": {"hexsha": "143a68142be5fc88ea3bb385eaaa22b7c4357249", "size": 13795, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "lib/Core/HashTableHandler.cpp", "max_stars_repo_name": "qiaokang92/P4wn", "max_stars_repo_head_hexsha": "cd2418de2dff238f67508898e3bfdf2aae1889a4", "max_stars_repo_licenses": ["NCSA"], "max_stars_count": 10.0, "max_stars_repo_stars_event_min_datetime": "2020-12-26T07:18:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-11T23:46:13.000Z", "max_issues_repo_path": "lib/Core/HashTableHandler.cpp", "max_issues_repo_name": "qiaokang92/P4wn", "max_issues_repo_head_hexsha": "cd2418de2dff238f67508898e3bfdf2aae1889a4", "max_issues_repo_licenses": ["NCSA"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-05-25T03:54:19.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-25T04:22:29.000Z", "max_forks_repo_path": "lib/Core/HashTableHandler.cpp", "max_forks_repo_name": "qiaokang92/P4wn", "max_forks_repo_head_hexsha": "cd2418de2dff238f67508898e3bfdf2aae1889a4", "max_forks_repo_licenses": ["NCSA"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.6339285714, "max_line_length": 86, "alphanum_fraction": 0.5809351214, "num_tokens": 4030, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7090191337850932, "lm_q2_score": 0.49218813572079556, "lm_q1q2_score": 0.3489708056480583}} {"text": "//==============================================================================\n// Copyright 2003 - 2011 LASMEA UMR 6602 CNRS/Univ. Clermont II\n// Copyright 2009 - 2011 LRI UMR 8623 CNRS/Univ Paris Sud XI\n//\n// Distributed under the Boost Software License, Version 1.0.\n// See accompanying file LICENSE.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt\n//==============================================================================\n#ifndef NT2_TOOLBOX_POLYNOMIALS_FUNCTIONS_SCALAR_IMPL_HORNER_HPP_INCLUDED\n#define NT2_TOOLBOX_POLYNOMIALS_FUNCTIONS_SCALAR_IMPL_HORNER_HPP_INCLUDED\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace nt2\n{\n //////////////////////////////////////////////////////////////////////////////\n // static unrollign of horner scheme\n // Coefficients are given in decreasing powers and hexadecimal form\n // horner< NT2_HORNER_COEFF(float,3,(0x3f800000,0x40000000,0x40400000))>(2.0f)\n // means ((1*x+2)*x+3) or x^2+2x+3\n //////////////////////////////////////////////////////////////////////////////\n namespace details\n {\n template struct static_horner_\n {\n template struct result;\n template struct result : meta::strip {};\n\n template inline\n T operator()(T const& x) const\n {\n static_horner_::type> callee;\n return fma( x\n , callee(x)\n , Const::type::value>()\n );\n }\n };\n\n template struct static_horner_<1,Seq>\n {\n template struct result;\n template struct result : meta::strip {};\n\n template inline\n T operator()(T const& ) const\n {\n return Const::type::value >();\n }\n };\n }\n\n //////////////////////////////////////////////////////////////////////////////\n /// @brief Static Horner scheme\n //////////////////////////////////////////////////////////////////////////////\n template\n static inline Type horner( Type const& x )\n {\n details::static_horner_::value,Coeff> callee;\n return callee(x);\n }\n}\n\n#define NT2_COEFF_GEN(z,n,text) \\\nboost::mpl::integral_c< BOOST_DISPATCH_PP_STRIP(BOOST_PP_TUPLE_ELEM(3,0,text)) \\\n , BOOST_PP_TUPLE_ELEM(BOOST_PP_TUPLE_ELEM(3,1,text) \\\n ,n \\\n ,BOOST_PP_TUPLE_ELEM(3,2,text) \\\n ) \\\n > \\\n/**/\n\n////////////////////////////////////////////////////////////////////////////////\n// Horner coefficient building macro\n////////////////////////////////////////////////////////////////////////////////\n#define NT2_HORNER_COEFF(Type, Size, Seq) \\\nboost::mpl::vector< BOOST_PP_ENUM(Size \\\n ,NT2_COEFF_GEN \\\n ,((nt2::meta::as_integer::type),Size,Seq)\\\n ) > \\\n/**/\n\n////////////////////////////////////////////////////////////////////////////////\n// Horner coefficient building macro for template dependant Type\n////////////////////////////////////////////////////////////////////////////////\n#define NT2_HORNER_COEFF_T(Type, Size, Seq) \\\nboost::mpl::vector< BOOST_PP_ENUM(Size \\\n ,NT2_COEFF_GEN \\\n ,((typename nt2::meta::as_integer::type)\\\n ,Size \\\n ,Seq) \\\n ) > \\\n/**/\n\n\n\n\n\n#endif\n", "meta": {"hexsha": "605ae22242b146eb7d08c980e293790e84e6028e", "size": 4756, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "modules/core/polynomials/include/nt2/toolbox/polynomials/functions/scalar/impl/horner.hpp", "max_stars_repo_name": "timblechmann/nt2", "max_stars_repo_head_hexsha": "6c71f7063ca4e5975c9c019877e6b2fe07c9e4ce", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2016-09-14T00:23:53.000Z", "max_stars_repo_stars_event_max_datetime": "2018-01-14T12:51:18.000Z", "max_issues_repo_path": "modules/core/polynomials/include/nt2/toolbox/polynomials/functions/scalar/impl/horner.hpp", "max_issues_repo_name": "timblechmann/nt2", "max_issues_repo_head_hexsha": "6c71f7063ca4e5975c9c019877e6b2fe07c9e4ce", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "modules/core/polynomials/include/nt2/toolbox/polynomials/functions/scalar/impl/horner.hpp", "max_forks_repo_name": "timblechmann/nt2", "max_forks_repo_head_hexsha": "6c71f7063ca4e5975c9c019877e6b2fe07c9e4ce", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.8468468468, "max_line_length": 91, "alphanum_fraction": 0.4222035324, "num_tokens": 894, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6001883735630721, "lm_q2_score": 0.5813030906443133, "lm_q1q2_score": 0.34889135652099745}} {"text": "/**\n * \\file NearestNeighbor.hpp\n * \\brief Header for GeographicLib::NearestNeighbor class\n *\n * Copyright (c) Charles Karney (2016-2019) and licensed\n * under the MIT/X11 License. For more information, see\n * https://geographiclib.sourceforge.io/\n **********************************************************************/\n\n#if !defined(GEOGRAPHICLIB_NEARESTNEIGHBOR_HPP)\n#define GEOGRAPHICLIB_NEARESTNEIGHBOR_HPP 1\n\n#include // for nth_element, max_element, etc.\n#include \n#include // for priority_queue\n#include // for swap + pair\n#include \n#include \n#include \n#include \n#include \n// Only for GeographicLib::GeographicErr\n#include \n\n#if defined(GEOGRAPHICLIB_HAVE_BOOST_SERIALIZATION) && \\\n GEOGRAPHICLIB_HAVE_BOOST_SERIALIZATION\n#include \n#include \n#include \n#include \n#endif\n\n#if defined(_MSC_VER)\n// Squelch warnings about constant conditional expressions\n# pragma warning (push)\n# pragma warning (disable: 4127)\n#endif\n\nnamespace GeographicLib {\n\n /**\n * \\brief Nearest-neighbor calculations\n *\n * This class solves the nearest-neighbor problm using a vantage-point tree\n * as described in \\ref nearest.\n *\n * This class is templated so that it can handle arbitrary metric spaces as\n * follows:\n *\n * @tparam dist_t the type used for measuring distances; it can be a real or\n * signed integer type; in typical geodetic applications, \\e dist_t might\n * be double.\n * @tparam pos_t the type for specifying the positions of points; geodetic\n * application might bundled the latitude and longitude into a\n * std::pair.\n * @tparam distfun_t the type of a function object which takes takes two\n * positions (of type \\e pos_t) and returns the distance (of type \\e\n * dist_t); in geodetic applications, this might be a class which is\n * constructed with a Geodesic object and which implements a member\n * function with a signature dist_t operator() (const pos_t&, const\n * pos_t&) const, which returns the geodesic distance between two\n * points.\n *\n * \\note The distance measure must satisfy the triangle inequality, \\f$\n * d(a,c) \\le d(a,b) + d(b,c) \\f$ for all points \\e a, \\e b, \\e c. The\n * geodesic distance (given by Geodesic::Inverse) does, while the great\n * ellipse distance and the rhumb line distance do not. If you use\n * the ordinary Euclidean distance, i.e., \\f$ \\sqrt{(x_a-x_b)^2 +\n * (y_a-y_b)^2} \\f$ for two dimensions, don't be tempted to leave out the\n * square root in the interests of \"efficiency\"; the squared distance does\n * not satisfy the triangle inequality!\n *\n * \\note This is a \"header-only\" implementation and, as such, depends in a\n * minimal way on the rest of GeographicLib (the only dependency is through\n * the use of GeographicLib::GeographicErr for handling compile-time and\n * run-time exceptions). Therefore, it is easy to extract this class from\n * the rest of GeographicLib and use it as a stand-alone facility.\n *\n * The \\e dist_t type must support numeric_limits queries (specifically:\n * is_signed, is_integer, max(), digits).\n *\n * The NearestNeighbor object is constructed with a vector of points (type \\e\n * pos_t) and a distance function (type \\e distfun_t). However the object\n * does \\e not store the points. When querying the object with Search(),\n * it's necessary to supply the same vector of points and the same distance\n * function.\n *\n * There's no capability in this implementation to add or remove points from\n * the set. Instead Initialize() should be called to re-initialize the\n * object with the modified vector of points.\n *\n * Because of the overhead in constructing a NearestNeighbor object for a\n * large set of points, functions Save() and Load() are provided to save the\n * object to an external file. operator<<(), operator>>() and Boost\n * serialization can also be used to save and restore a NearestNeighbor\n * object. This is illustrated in the example.\n *\n * Example of use:\n * \\include example-NearestNeighbor.cpp\n **********************************************************************/\n template \n class NearestNeighbor {\n // For tracking changes to the I/O format\n static const int version = 1;\n // This is what we get \"free\"; but if sizeof(dist_t) = 1 (unlikely), allow\n // 4 slots (and this accommodates the default value bucket = 4).\n static const int maxbucket =\n (2 + ((4 * sizeof(dist_t)) / sizeof(int) >= 2 ?\n (4 * sizeof(dist_t)) / sizeof(int) : 2));\n public:\n\n /**\n * Default constructor for NearestNeighbor.\n *\n * This is equivalent to specifying an empty set of points.\n **********************************************************************/\n NearestNeighbor() : _numpoints(0), _bucket(0), _cost(0) {}\n\n /**\n * Constructor for NearestNeighbor.\n *\n * @param[in] pts a vector of points to include in the set.\n * @param[in] dist the distance function object.\n * @param[in] bucket the size of the buckets at the leaf nodes; this must\n * lie in [0, 2 + 4*sizeof(dist_t)/sizeof(int)] (default 4).\n * @exception GeographicErr if the value of \\e bucket is out of bounds or\n * the size of \\e pts is too big for an int.\n * @exception std::bad_alloc if memory for the tree can't be allocated.\n *\n * \\e pts may contain coincident points (i.e., the distance between them\n * vanishes); these are treated as distinct.\n *\n * The choice of \\e bucket is a tradeoff between space and efficiency. A\n * larger \\e bucket decreases the size of the NearestNeighbor object which\n * scales as pts.size() / max(1, bucket) and reduces the number of distance\n * calculations to construct the object by log2(bucket) * pts.size().\n * However each search then requires about bucket additional distance\n * calculations.\n *\n * \\warning The distances computed by \\e dist must satisfy the standard\n * metric conditions. If not, the results are undefined. Neither the data\n * in \\e pts nor the query points should contain NaNs or infinities because\n * such data violates the metric conditions.\n *\n * \\warning The same arguments \\e pts and \\e dist must be provided\n * to the Search() function.\n **********************************************************************/\n NearestNeighbor(const std::vector& pts, const distfun_t& dist,\n int bucket = 4) {\n Initialize(pts, dist, bucket);\n }\n\n /**\n * Initialize or re-initialize NearestNeighbor.\n *\n * @param[in] pts a vector of points to include in the tree.\n * @param[in] dist the distance function object.\n * @param[in] bucket the size of the buckets at the leaf nodes; this must\n * lie in [0, 2 + 4*sizeof(dist_t)/sizeof(int)] (default 4).\n * @exception GeographicErr if the value of \\e bucket is out of bounds or\n * the size of \\e pts is too big for an int.\n * @exception std::bad_alloc if memory for the tree can't be allocated.\n *\n * See also the documentation on the constructor.\n *\n * If an exception is thrown, the state of the NearestNeighbor is\n * unchanged.\n **********************************************************************/\n void Initialize(const std::vector& pts, const distfun_t& dist,\n int bucket = 4) {\n static_assert(std::numeric_limits::is_signed,\n \"dist_t must be a signed type\");\n if (!( 0 <= bucket && bucket <= maxbucket ))\n throw GeographicLib::GeographicErr\n (\"bucket must lie in [0, 2 + 4*sizeof(dist_t)/sizeof(int)]\");\n if (pts.size() > size_t(std::numeric_limits::max()))\n throw GeographicLib::GeographicErr(\"pts array too big\");\n // the pair contains distance+id\n std::vector ids(pts.size());\n for (int k = int(ids.size()); k--;)\n ids[k] = std::make_pair(dist_t(0), k);\n int cost = 0;\n std::vector tree;\n init(pts, dist, bucket, tree, ids, cost,\n 0, int(ids.size()), int(ids.size()/2));\n _tree.swap(tree);\n _numpoints = int(pts.size());\n _bucket = bucket;\n _mc = _sc = 0;\n _cost = cost; _c1 = _k = _cmax = 0;\n _cmin = std::numeric_limits::max();\n }\n\n /**\n * Search the NearestNeighbor.\n *\n * @param[in] pts the vector of points used for initialization.\n * @param[in] dist the distance function object used for initialization.\n * @param[in] query the query point.\n * @param[out] ind a vector of indices to the closest points found.\n * @param[in] k the number of points to search for (default = 1).\n * @param[in] maxdist only return points with distances of \\e maxdist or\n * less from \\e query (default is the maximum \\e dist_t).\n * @param[in] mindist only return points with distances of more than\n * \\e mindist from \\e query (default = −1).\n * @param[in] exhaustive whether to do an exhaustive search (default true).\n * @param[in] tol the tolerance on the results (default 0).\n * @return the distance to the closest point found (−1 if no points\n * are found).\n * @exception GeographicErr if \\e pts has a different size from that used\n * to construct the object.\n *\n * The indices returned in \\e ind are sorted by distance from \\e query\n * (closest first).\n *\n * The simplest invocation is with just the 4 non-optional arguments. This\n * returns the closest distance and the index to the closest point in\n * ind0. If there are several points equally close, then\n * ind0 gives the index of an arbirary one of them. If\n * there's no closest point (because the set of points is empty), then \\e\n * ind is empty and −1 is returned.\n *\n * With \\e exhaustive = true and \\e tol = 0 (their default values), this\n * finds the indices of \\e k closest neighbors to \\e query whose distances\n * to \\e query are in (\\e mindist, \\e maxdist]. If \\e mindist and \\e\n * maxdist have their default values, then these bounds have no effect. If\n * \\e query is one of the points in the tree, then set \\e mindist = 0 to\n * prevent this point (and other coincident points) from being returned.\n *\n * If \\e exhaustive = false, exit as soon as \\e k results satisfying the\n * distance criteria are found. If less than \\e k results are returned\n * then the search was exhaustive even if \\e exhaustive = false.\n *\n * If \\e tol is positive, do an approximate search; in this case the\n * results are to be interpreted as follows: if the k'th distance is\n * \\e dk, then all results with distances less than or equal \\e dk −\n * \\e tol are correct; all others are suspect — there may be other\n * closer results with distances greater or equal to \\e dk − \\e tol.\n * If less than \\e k results are found, then the search is exact.\n *\n * \\e mindist should be used to exclude a \"small\" neighborhood of the query\n * point (relative to the average spacing of the data). If \\e mindist is\n * large, the efficiency of the search deteriorates.\n *\n * \\note Only the shortest distance is returned (as as the function value).\n * The distances to other points (indexed by indj\n * for \\e j > 0) can be found by invoking \\e dist again.\n *\n * \\warning The arguments \\e pts and \\e dist must be identical to those\n * used to initialize the NearestNeighbor; if not, this function will\n * return some meaningless result (however, if the size of \\e pts is wrong,\n * this function throw an exception).\n *\n * \\warning The query point cannot be a NaN or infinite because then the\n * metric conditions are violated.\n **********************************************************************/\n dist_t Search(const std::vector& pts, const distfun_t& dist,\n const pos_t& query,\n std::vector& ind,\n int k = 1,\n dist_t maxdist = std::numeric_limits::max(),\n dist_t mindist = -1,\n bool exhaustive = true,\n dist_t tol = 0) const {\n if (_numpoints != int(pts.size()))\n throw GeographicLib::GeographicErr(\"pts array has wrong size\");\n std::priority_queue results;\n if (_numpoints > 0 && k > 0 && maxdist > mindist) {\n // distance to the kth closest point so far\n dist_t tau = maxdist;\n // first is negative of how far query is outside boundary of node\n // +1 if on boundary or inside\n // second is node index\n std::priority_queue todo;\n todo.push(std::make_pair(dist_t(1), int(_tree.size()) - 1));\n int c = 0;\n while (!todo.empty()) {\n int n = todo.top().second;\n dist_t d = -todo.top().first;\n todo.pop();\n dist_t tau1 = tau - tol;\n // compare tau and d again since tau may have become smaller.\n if (!( n >= 0 && tau1 >= d )) continue;\n const Node& current = _tree[n];\n dist_t dst = 0; // to suppress warning about uninitialized variable\n bool exitflag = false, leaf = current.index < 0;\n for (int i = 0; i < (leaf ? _bucket : 1); ++i) {\n int index = leaf ? current.leaves[i] : current.index;\n if (index < 0) break;\n dst = dist(pts[index], query);\n ++c;\n\n if (dst > mindist && dst <= tau) {\n if (int(results.size()) == k) results.pop();\n results.push(std::make_pair(dst, index));\n if (int(results.size()) == k) {\n if (exhaustive)\n tau = results.top().first;\n else {\n exitflag = true;\n break;\n }\n if (tau <= tol) {\n exitflag = true;\n break;\n }\n }\n }\n }\n if (exitflag) break;\n\n if (current.index < 0) continue;\n tau1 = tau - tol;\n for (int l = 0; l < 2; ++l) {\n if (current.data.child[l] >= 0 &&\n dst + current.data.upper[l] >= mindist) {\n if (dst < current.data.lower[l]) {\n d = current.data.lower[l] - dst;\n if (tau1 >= d)\n todo.push(std::make_pair(-d, current.data.child[l]));\n } else if (dst > current.data.upper[l]) {\n d = dst - current.data.upper[l];\n if (tau1 >= d)\n todo.push(std::make_pair(-d, current.data.child[l]));\n } else\n todo.push(std::make_pair(dist_t(1), current.data.child[l]));\n }\n }\n }\n ++_k;\n _c1 += c;\n double omc = _mc;\n _mc += (c - omc) / _k;\n _sc += (c - omc) * (c - _mc);\n if (c > _cmax) _cmax = c;\n if (c < _cmin) _cmin = c;\n }\n\n dist_t d = -1;\n ind.resize(results.size());\n\n for (int i = int(ind.size()); i--;) {\n ind[i] = int(results.top().second);\n if (i == 0) d = results.top().first;\n results.pop();\n }\n return d;\n\n }\n\n /**\n * @return the total number of points in the set.\n **********************************************************************/\n int NumPoints() const { return _numpoints; }\n\n /**\n * Write the object to an I/O stream.\n *\n * @param[in,out] os the stream to write to.\n * @param[in] bin if true (the default) save in binary mode.\n * @exception std::bad_alloc if memory for the string representation of the\n * object can't be allocated.\n *\n * The counters tracking the statistics of searches are not saved; however\n * the initializtion cost is saved. The format of the binary saves is \\e\n * not portable.\n *\n * \\note \n * Boost serialization can also be used to save and restore a\n * NearestNeighbor object. This requires that the\n * GEOGRAPHICLIB_HAVE_BOOST_SERIALIZATION macro be defined.\n **********************************************************************/\n void Save(std::ostream& os, bool bin = true) const {\n int realspec = std::numeric_limits::digits *\n (std::numeric_limits::is_integer ? -1 : 1);\n if (bin) {\n char id[] = \"NearestNeighbor_\";\n os.write(id, 16);\n int buf[6];\n buf[0] = version;\n buf[1] = realspec;\n buf[2] = _bucket;\n buf[3] = _numpoints;\n buf[4] = int(_tree.size());\n buf[5] = _cost;\n os.write(reinterpret_cast(buf), 6 * sizeof(int));\n for (int i = 0; i < int(_tree.size()); ++i) {\n const Node& node = _tree[i];\n os.write(reinterpret_cast(&node.index), sizeof(int));\n if (node.index >= 0) {\n os.write(reinterpret_cast(node.data.lower),\n 2 * sizeof(dist_t));\n os.write(reinterpret_cast(node.data.upper),\n 2 * sizeof(dist_t));\n os.write(reinterpret_cast(node.data.child),\n 2 * sizeof(int));\n } else {\n os.write(reinterpret_cast(node.leaves),\n _bucket * sizeof(int));\n }\n }\n } else {\n std::stringstream ostring;\n // Ensure enough precision for type dist_t. With C++11, max_digits10\n // can be used instead.\n if (!std::numeric_limits::is_integer) {\n static const int prec\n = int(std::ceil(std::numeric_limits::digits *\n std::log10(2.0) + 1));\n ostring.precision(prec);\n }\n ostring << version << \" \" << realspec << \" \" << _bucket << \" \"\n << _numpoints << \" \" << _tree.size() << \" \" << _cost;\n for (int i = 0; i < int(_tree.size()); ++i) {\n const Node& node = _tree[i];\n ostring << \"\\n\" << node.index;\n if (node.index >= 0) {\n for (int l = 0; l < 2; ++l)\n ostring << \" \" << node.data.lower[l] << \" \" << node.data.upper[l]\n << \" \" << node.data.child[l];\n } else {\n for (int l = 0; l < _bucket; ++l)\n ostring << \" \" << node.leaves[l];\n }\n }\n os << ostring.str();\n }\n }\n\n /**\n * Read the object from an I/O stream.\n *\n * @param[in,out] is the stream to read from\n * @param[in] bin if true (the default) load in binary mode.\n * @exception GeographicErr if the state read from \\e is is illegal.\n * @exception std::bad_alloc if memory for the tree can't be allocated.\n *\n * The counters tracking the statistics of searches are reset by this\n * operation. Binary data must have been saved on a machine with the same\n * architecture. If an exception is thrown, the state of the\n * NearestNeighbor is unchanged.\n *\n * \\note \n * Boost serialization can also be used to save and restore a\n * NearestNeighbor object. This requires that the\n * GEOGRAPHICLIB_HAVE_BOOST_SERIALIZATION macro be defined.\n *\n * \\warning The same arguments \\e pts and \\e dist used for\n * initialization must be provided to the Search() function.\n **********************************************************************/\n void Load(std::istream& is, bool bin = true) {\n int version1, realspec, bucket, numpoints, treesize, cost;\n if (bin) {\n char id[17];\n is.read(id, 16);\n id[16] = '\\0';\n if (!(std::strcmp(id, \"NearestNeighbor_\") == 0))\n throw GeographicLib::GeographicErr(\"Bad ID\");\n is.read(reinterpret_cast(&version1), sizeof(int));\n is.read(reinterpret_cast(&realspec), sizeof(int));\n is.read(reinterpret_cast(&bucket), sizeof(int));\n is.read(reinterpret_cast(&numpoints), sizeof(int));\n is.read(reinterpret_cast(&treesize), sizeof(int));\n is.read(reinterpret_cast(&cost), sizeof(int));\n } else {\n if (!( is >> version1 >> realspec >> bucket >> numpoints >> treesize\n >> cost ))\n throw GeographicLib::GeographicErr(\"Bad header\");\n }\n if (!( version1 == version ))\n throw GeographicLib::GeographicErr(\"Incompatible version\");\n if (!( realspec == std::numeric_limits::digits *\n (std::numeric_limits::is_integer ? -1 : 1) ))\n throw GeographicLib::GeographicErr(\"Different dist_t types\");\n if (!( 0 <= bucket && bucket <= maxbucket ))\n throw GeographicLib::GeographicErr(\"Bad bucket size\");\n if (!( 0 <= treesize && treesize <= numpoints ))\n throw\n GeographicLib::GeographicErr(\"Bad number of points or tree size\");\n if (!( 0 <= cost ))\n throw GeographicLib::GeographicErr(\"Bad value for cost\");\n std::vector tree;\n tree.reserve(treesize);\n for (int i = 0; i < treesize; ++i) {\n Node node;\n if (bin) {\n is.read(reinterpret_cast(&node.index), sizeof(int));\n if (node.index >= 0) {\n is.read(reinterpret_cast(node.data.lower),\n 2 * sizeof(dist_t));\n is.read(reinterpret_cast(node.data.upper),\n 2 * sizeof(dist_t));\n is.read(reinterpret_cast(node.data.child),\n 2 * sizeof(int));\n } else {\n is.read(reinterpret_cast(node.leaves),\n bucket * sizeof(int));\n for (int l = bucket; l < maxbucket; ++l)\n node.leaves[l] = 0;\n }\n } else {\n if (!( is >> node.index ))\n throw GeographicLib::GeographicErr(\"Bad index\");\n if (node.index >= 0) {\n for (int l = 0; l < 2; ++l) {\n if (!( is >> node.data.lower[l] >> node.data.upper[l]\n >> node.data.child[l] ))\n throw GeographicLib::GeographicErr(\"Bad node data\");\n }\n } else {\n // Must be at least one valid leaf followed by a sequence end\n // markers (-1).\n for (int l = 0; l < bucket; ++l) {\n if (!( is >> node.leaves[l] ))\n throw GeographicLib::GeographicErr(\"Bad leaf data\");\n }\n for (int l = bucket; l < maxbucket; ++l)\n node.leaves[l] = 0;\n }\n }\n node.Check(numpoints, treesize, bucket);\n tree.push_back(node);\n }\n _tree.swap(tree);\n _numpoints = numpoints;\n _bucket = bucket;\n _mc = _sc = 0;\n _cost = cost; _c1 = _k = _cmax = 0;\n _cmin = std::numeric_limits::max();\n }\n\n /**\n * Write the object to stream \\e os as text.\n *\n * @param[in,out] os the output stream.\n * @param[in] t the NearestNeighbor object to be saved.\n * @exception std::bad_alloc if memory for the string representation of the\n * object can't be allocated.\n **********************************************************************/\n friend std::ostream& operator<<(std::ostream& os, const NearestNeighbor& t)\n { t.Save(os, false); return os; }\n\n /**\n * Read the object from stream \\e is as text.\n *\n * @param[in,out] is the input stream.\n * @param[out] t the NearestNeighbor object to be loaded.\n * @exception GeographicErr if the state read from \\e is is illegal.\n * @exception std::bad_alloc if memory for the tree can't be allocated.\n **********************************************************************/\n friend std::istream& operator>>(std::istream& is, NearestNeighbor& t)\n { t.Load(is, false); return is; }\n\n /**\n * Swap with another NearestNeighbor object.\n *\n * @param[in,out] t the NearestNeighbor object to swap with.\n **********************************************************************/\n void swap(NearestNeighbor& t) {\n std::swap(_numpoints, t._numpoints);\n std::swap(_bucket, t._bucket);\n std::swap(_cost, t._cost);\n _tree.swap(t._tree);\n std::swap(_mc, t._mc);\n std::swap(_sc, t._sc);\n std::swap(_c1, t._c1);\n std::swap(_k, t._k);\n std::swap(_cmin, t._cmin);\n std::swap(_cmax, t._cmax);\n }\n\n /**\n * The accumulated statistics on the searches so far.\n *\n * @param[out] setupcost the cost of initializing the NearestNeighbor.\n * @param[out] numsearches the number of calls to Search().\n * @param[out] searchcost the total cost of the calls to Search().\n * @param[out] mincost the minimum cost of a Search().\n * @param[out] maxcost the maximum cost of a Search().\n * @param[out] mean the mean cost of a Search().\n * @param[out] sd the standard deviation in the cost of a Search().\n *\n * Here \"cost\" measures the number of distance calculations needed. Note\n * that the accumulation of statistics is \\e not thread safe.\n **********************************************************************/\n void Statistics(int& setupcost, int& numsearches, int& searchcost,\n int& mincost, int& maxcost,\n double& mean, double& sd) const {\n setupcost = _cost; numsearches = _k; searchcost = _c1;\n mincost = _cmin; maxcost = _cmax;\n mean = _mc; sd = std::sqrt(_sc / (_k - 1));\n }\n\n /**\n * Reset the counters for the accumulated statistics on the searches so\n * far.\n **********************************************************************/\n void ResetStatistics() const {\n _mc = _sc = 0;\n _c1 = _k = _cmax = 0;\n _cmin = std::numeric_limits::max();\n }\n\n private:\n // Package up a dist_t and an int. We will want to sort on the dist_t so\n // put it first.\n typedef std::pair item;\n // \\cond SKIP\n class Node {\n public:\n struct bounds {\n dist_t lower[2], upper[2]; // bounds on inner/outer distances\n int child[2];\n };\n union {\n bounds data;\n int leaves[maxbucket];\n };\n int index;\n\n Node()\n : index(-1)\n {\n for (int i = 0; i < 2; ++i) {\n data.lower[i] = data.upper[i] = 0;\n data.child[i] = -1;\n }\n }\n\n // Sanity check on a Node\n void Check(int numpoints, int treesize, int bucket) const {\n if (!( -1 <= index && index < numpoints ))\n throw GeographicLib::GeographicErr(\"Bad index\");\n if (index >= 0) {\n if (!( -1 <= data.child[0] && data.child[0] < treesize &&\n -1 <= data.child[1] && data.child[1] < treesize ))\n throw GeographicLib::GeographicErr(\"Bad child pointers\");\n if (!( 0 <= data.lower[0] && data.lower[0] <= data.upper[0] &&\n data.upper[0] <= data.lower[1] &&\n data.lower[1] <= data.upper[1] ))\n throw GeographicLib::GeographicErr(\"Bad bounds\");\n } else {\n // Must be at least one valid leaf followed by a sequence end markers\n // (-1).\n bool start = true;\n for (int l = 0; l < bucket; ++l) {\n if (!( (start ?\n ((l == 0 ? 0 : -1) <= leaves[l] && leaves[l] < numpoints) :\n leaves[l] == -1) ))\n throw GeographicLib::GeographicErr(\"Bad leaf data\");\n start = leaves[l] >= 0;\n }\n for (int l = bucket; l < maxbucket; ++l) {\n if (leaves[l] != 0)\n throw GeographicLib::GeographicErr(\"Bad leaf data\");\n }\n }\n }\n\n#if defined(GEOGRAPHICLIB_HAVE_BOOST_SERIALIZATION) && \\\n GEOGRAPHICLIB_HAVE_BOOST_SERIALIZATION\n friend class boost::serialization::access;\n template\n void save(Archive& ar, const unsigned int) const {\n ar & boost::serialization::make_nvp(\"index\", index);\n if (index < 0)\n ar & boost::serialization::make_nvp(\"leaves\", leaves);\n else\n ar & boost::serialization::make_nvp(\"lower\", data.lower)\n & boost::serialization::make_nvp(\"upper\", data.upper)\n & boost::serialization::make_nvp(\"child\", data.child);\n }\n template\n void load(Archive& ar, const unsigned int) {\n ar & boost::serialization::make_nvp(\"index\", index);\n if (index < 0)\n ar & boost::serialization::make_nvp(\"leaves\", leaves);\n else\n ar & boost::serialization::make_nvp(\"lower\", data.lower)\n & boost::serialization::make_nvp(\"upper\", data.upper)\n & boost::serialization::make_nvp(\"child\", data.child);\n }\n template\n void serialize(Archive& ar, const unsigned int file_version)\n { boost::serialization::split_member(ar, *this, file_version); }\n#endif\n };\n // \\endcond\n#if defined(GEOGRAPHICLIB_HAVE_BOOST_SERIALIZATION) && \\\n GEOGRAPHICLIB_HAVE_BOOST_SERIALIZATION\n friend class boost::serialization::access;\n template void save(Archive& ar, const unsigned) const {\n int realspec = std::numeric_limits::digits *\n (std::numeric_limits::is_integer ? -1 : 1);\n // Need to use version1, otherwise load error in debug mode on Linux:\n // undefined reference to GeographicLib::NearestNeighbor<...>::version.\n int version1 = version;\n ar & boost::serialization::make_nvp(\"version\", version1)\n & boost::serialization::make_nvp(\"realspec\", realspec)\n & boost::serialization::make_nvp(\"bucket\", _bucket)\n & boost::serialization::make_nvp(\"numpoints\", _numpoints)\n & boost::serialization::make_nvp(\"cost\", _cost)\n & boost::serialization::make_nvp(\"tree\", _tree);\n }\n template void load(Archive& ar, const unsigned) {\n int version1, realspec, bucket, numpoints, cost;\n ar & boost::serialization::make_nvp(\"version\", version1);\n if (version1 != version)\n throw GeographicLib::GeographicErr(\"Incompatible version\");\n std::vector tree;\n ar & boost::serialization::make_nvp(\"realspec\", realspec);\n if (!( realspec == std::numeric_limits::digits *\n (std::numeric_limits::is_integer ? -1 : 1) ))\n throw GeographicLib::GeographicErr(\"Different dist_t types\");\n ar & boost::serialization::make_nvp(\"bucket\", bucket);\n if (!( 0 <= bucket && bucket <= maxbucket ))\n throw GeographicLib::GeographicErr(\"Bad bucket size\");\n ar & boost::serialization::make_nvp(\"numpoints\", numpoints)\n & boost::serialization::make_nvp(\"cost\", cost)\n & boost::serialization::make_nvp(\"tree\", tree);\n if (!( 0 <= int(tree.size()) && int(tree.size()) <= numpoints ))\n throw\n GeographicLib::GeographicErr(\"Bad number of points or tree size\");\n for (int i = 0; i < int(tree.size()); ++i)\n tree[i].Check(numpoints, int(tree.size()), bucket);\n _tree.swap(tree);\n _numpoints = numpoints;\n _bucket = bucket;\n _mc = _sc = 0;\n _cost = cost; _c1 = _k = _cmax = 0;\n _cmin = std::numeric_limits::max();\n }\n template\n void serialize(Archive& ar, const unsigned int file_version)\n { boost::serialization::split_member(ar, *this, file_version); }\n#endif\n\n int _numpoints, _bucket, _cost;\n std::vector _tree;\n // Counters to track stastistics on the cost of searches\n mutable double _mc, _sc;\n mutable int _c1, _k, _cmin, _cmax;\n\n int init(const std::vector& pts, const distfun_t& dist, int bucket,\n std::vector& tree, std::vector& ids, int& cost,\n int l, int u, int vp) {\n\n if (u == l)\n return -1;\n Node node;\n\n if (u - l > (bucket == 0 ? 1 : bucket)) {\n\n // choose a vantage point and move it to the start\n int i = vp;\n std::swap(ids[l], ids[i]);\n\n int m = (u + l + 1) / 2;\n\n for (int k = l + 1; k < u; ++k) {\n ids[k].first = dist(pts[ids[l].second], pts[ids[k].second]);\n ++cost;\n }\n // partition around the median distance\n std::nth_element(ids.begin() + l + 1,\n ids.begin() + m,\n ids.begin() + u);\n node.index = ids[l].second;\n if (m > l + 1) { // node.child[0] is possibly empty\n typename std::vector::iterator\n t = std::min_element(ids.begin() + l + 1, ids.begin() + m);\n node.data.lower[0] = t->first;\n t = std::max_element(ids.begin() + l + 1, ids.begin() + m);\n node.data.upper[0] = t->first;\n // Use point with max distance as vantage point; this point act as a\n // \"corner\" point and leads to a good partition.\n node.data.child[0] = init(pts, dist, bucket, tree, ids, cost,\n l + 1, m, int(t - ids.begin()));\n }\n typename std::vector::iterator\n t = std::max_element(ids.begin() + m, ids.begin() + u);\n node.data.lower[1] = ids[m].first;\n node.data.upper[1] = t->first;\n // Use point with max distance as vantage point here too\n node.data.child[1] = init(pts, dist, bucket, tree, ids, cost,\n m, u, int(t - ids.begin()));\n } else {\n if (bucket == 0)\n node.index = ids[l].second;\n else {\n node.index = -1;\n // Sort the bucket entries so that the tree is independent of the\n // implementation of nth_element.\n std::sort(ids.begin() + l, ids.begin() + u);\n for (int i = l; i < u; ++i)\n node.leaves[i-l] = ids[i].second;\n for (int i = u - l; i < bucket; ++i)\n node.leaves[i] = -1;\n for (int i = bucket; i < maxbucket; ++i)\n node.leaves[i] = 0;\n }\n }\n\n tree.push_back(node);\n return int(tree.size()) - 1;\n }\n\n };\n\n} // namespace GeographicLib\n\nnamespace std {\n\n /**\n * Swap two GeographicLib::NearestNeighbor objects.\n *\n * @tparam dist_t the type used for measuring distances.\n * @tparam pos_t the type for specifying the positions of points.\n * @tparam distfun_t the type for a function object which calculates\n * distances between points.\n * @param[in,out] a the first GeographicLib::NearestNeighbor to swap.\n * @param[in,out] b the second GeographicLib::NearestNeighbor to swap.\n **********************************************************************/\n template \n void swap(GeographicLib::NearestNeighbor& a,\n GeographicLib::NearestNeighbor& b) {\n a.swap(b);\n }\n\n} // namespace std\n\n#if defined(_MSC_VER)\n# pragma warning (pop)\n#endif\n\n#endif // GEOGRAPHICLIB_NEARESTNEIGHBOR_HPP\n", "meta": {"hexsha": "70cdcd68f4306275347e6fb6dce2eb5e463b47be", "size": 35717, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/GeographicLib/NearestNeighbor.hpp", "max_stars_repo_name": "TheNicker/geographiclib", "max_stars_repo_head_hexsha": "5e9b898734643954a9f6aafae3e9b8de429252bb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/GeographicLib/NearestNeighbor.hpp", "max_issues_repo_name": "TheNicker/geographiclib", "max_issues_repo_head_hexsha": "5e9b898734643954a9f6aafae3e9b8de429252bb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/GeographicLib/NearestNeighbor.hpp", "max_forks_repo_name": "TheNicker/geographiclib", "max_forks_repo_head_hexsha": "5e9b898734643954a9f6aafae3e9b8de429252bb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.6217183771, "max_line_length": 79, "alphanum_fraction": 0.5697287006, "num_tokens": 8913, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.5813030906443133, "lm_q1q2_score": 0.3488913482066966}} {"text": "//****************************************************************************\n// (c) 2008, 2009 by the openOR Team\n//****************************************************************************\n// The contents of this file are available under the GPL v2.0 license\n// or under the openOR comercial license. see\n// /Doc/openOR_free_license.txt or\n// /Doc/openOR_comercial_license.txt\n// for Details.\n//****************************************************************************\n/**\n* @file\n* @author Christian Winne\n* @ingroup openOR_core\n*/\n\n#ifndef openOR_core_math_create_hpp\n#define openOR_core_math_create_hpp\n\n#include \n#include \n#include \n\n#include \n\nnamespace openOR {\n\tnamespace Math {\n\n\t\tnamespace Impl {\n\t\t\t/**\n\t\t\t* Functor for Impl::VectorCompileIterator in order to copy the content of source vector into destination vector\n\t\t\t* \\internal\n\t\t\t*/\n\t\t\ttemplate \n\t\t\tstruct VectorCopy {\n\t\t\t\tvoid operator()(Vec& vec, const VecSrc& vecSrc) {\n\t\t\t\t\tget(vec) = get(vecSrc);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\ttemplate \n\t\t\tstruct MatrixCopy {\n\t\t\t\tvoid operator()(Mat& mat, const MatSrc& matSrc) {\n\t\t\t\t\tget(mat) = get(matSrc);\n\t\t\t\t}\n\t\t\t};\n\n\n\t\t\t/**\n\t\t\t* v0 is an vector because the destination vector is larger than Dimension 2.\n\t\t\t* \\internal\n\t\t\t*/\n\t\t\ttemplate\n\t\t\tstruct CreateVec2 {\n\t\t\t\tstatic Vec_type create(const Type2& v0,\n\t\t\t\t\ttypename VectorTraits::ValueType v1) \n\t\t\t\t{\n\t\t\t\t\tBOOST_MPL_ASSERT((typename VectorTraits::IsVector));\n\t\t\t\t\tVec_type t;\n\t\t\t\t\tImpl::VectorCompileTimeIterator < Vec_type, 0, VectorTraits::Dimension::value - 1 > ()\n\t\t\t\t\t\t.template apply(t, v0);\n\t\t\t\t\tget < VectorTraits::Dimension::value - 1 > (t) = v1;\n\t\t\t\t\treturn t;\n\t\t\t\t}\n\t\t\t};\n\n\t\t\t/**\n\t\t\t* v0 is a ValueType because the vector to create has dimension 2.\n\t\t\t* \\internal\n\t\t\t*/\n\t\t\ttemplate\n\t\t\tstruct CreateVec2 {\n\t\t\t\tstatic Type create(const Type2& v0,\n\t\t\t\t\ttypename VectorTraits::ValueType v1) {\n\t\t\t\t\t\tType t;\n\t\t\t\t\t\tget<0>(t) = static_cast::ValueType>(v0);\n\t\t\t\t\t\tget<1>(t) = static_cast::ValueType>(v1);\n\t\t\t\t\t\treturn t;\n\t\t\t\t}\n\t\t\t};\n\n\t\t\ttemplate\n\t\t\tstruct CreateMat2 {\n\t\t\t\tstatic Mat create(\n\t\t\t\t\tconst MatSrc& matSrc,\n\t\t\t\t\tconst Vec& v) \n\t\t\t\t{\n\t\t\t\t\tBOOST_MPL_ASSERT((typename MatrixTraits::IsMatrix));\n\t\t\t\t\tBOOST_MPL_ASSERT((typename VectorTraits::IsVector));\n\t\t\t\t\tMat mat = MatrixTraits::IDENTITY;\n\t\t\t\t\tImpl::MatrixCompileTimeIterator ::RowDimension::value - 1, 0, MatrixTraits::ColDimension::value - 1> ()\n\t\t\t\t\t\t.template apply(mat, matSrc);\n\n\t\t\t\t\tfor (int i = 0; i < VectorTraits::Dimension::value; ++i)\n\t\t\t\t\t{\n\t\t\t\t\t\tmat(i, MatrixTraits::ColDimension::value - 1) = v(i);\n\t\t\t\t\t}\n\t\t\t\t\treturn mat;\n\t\t\t\t}\n\t\t\t};\n\n\t\t\t/**\n\t\t\t* \n\t\t\t* \\internal\n\t\t\t*/\n\t\t\ttemplate\n\t\t\tstruct Create2 {\n\t\t\t\tstatic Type create(const Type2& v0, const Type3& v1) \n\t\t\t\t{\n\t\t\t\t\treturn CreateVec2::Dimension::value>::create(v0, v1);\n\t\t\t\t}\n\t\t\t};\n\n\n\t\t\t/**\n\t\t\t* \n\t\t\t* \\internal\n\t\t\t*/\n\t\t\ttemplate\n\t\t\tstruct Create2 {\n\t\t\t\tstatic Type create(const Type2& v0, const Type3& v1) \n\t\t\t\t{\n\t\t\t\t\treturn CreateMat2::create(v0, v1);\n\t\t\t\t}\n\t\t\t};\n\n\n\t\t\t/**\n\t\t\t* Type is a vector\n\t\t\t* \\internal\n\t\t\t*/\n\t\t\ttemplate\n\t\t\tstruct Create3 {\n\t\t\t\tstatic Type create(const Type2& v0, \n\t\t\t\t\tconst Type3& v1, \n\t\t\t\t\tconst Type4& v2) {\n\t\t\t\t\t\tBOOST_MPL_ASSERT((typename VectorTraits::IsVector));\n\t\t\t\t\t\tType t;\n\t\t\t\t\t\tget<0>(t) = static_cast::ValueType>(v0);\n\t\t\t\t\t\tget<1>(t) = static_cast::ValueType>(v1);\n\t\t\t\t\t\tget<2>(t) = static_cast::ValueType>(v2);\n\t\t\t\t\t\treturn t;\n\t\t\t\t}\n\t\t\t};\n\n\n\t\t\t/**\n\t\t\t* Type is matrix\n\t\t\t* \\internal\n\t\t\t*/\n\t\t\ttemplate\n\t\t\tstruct Create3 {\n\t\t\t\tstatic Type create(const Type2& v0, const Type3& v1, const Type4& v2) {\n\t\t\t\t\tBOOST_MPL_ASSERT((typename MatrixTraits::IsMatrix));\n\t\t\t\t\tType t = MatrixTraits::IDENTITY;\n\t\t\t\t\tsetXAxis(t, v0);\n\t\t\t\t\tsetYAxis(t, v1);\n\t\t\t\t\tsetZAxis(t, v2);\n\t\t\t\t\treturn t;\n\t\t\t\t}\n\t\t\t};\n\n\n\t\t\t/**\n\t\t\t* Type is a vector\n\t\t\t* \\internal\n\t\t\t*/\n\t\t\ttemplate\n\t\t\tstruct Create4 {\n\t\t\t\tstatic Type create(const Type2& v0, const Type3& v1, const Type4& v2, const Type5& v3) {\n\t\t\t\t\tBOOST_MPL_ASSERT((typename VectorTraits::IsVector));\n\t\t\t\t\tType t;\n\t\t\t\t\tget<0>(t) = static_cast::ValueType>(v0);\n\t\t\t\t\tget<1>(t) = static_cast::ValueType>(v1);\n\t\t\t\t\tget<2>(t) = static_cast::ValueType>(v2);\n\t\t\t\t\tget<3>(t) = static_cast::ValueType>(v3);\n\t\t\t\t\treturn t;\n\t\t\t\t}\n\t\t\t};\n\n\n\t\t\t/** \n\t\t\t* Type is matrix\n\t\t\t* \\internal\n\t\t\t*/\n\t\t\ttemplate\n\t\t\tstruct Create4 {\n\t\t\t\tstatic Type create(const Type2& v0, const Type3& v1, const Type4& v2, const Type5& v3) {\n\t\t\t\t\tType t = MatrixTraits::IDENTITY;\n\t\t\t\t\tsetXAxis(t, v0);\n\t\t\t\t\tsetYAxis(t, v1);\n\t\t\t\t\tsetZAxis(t, v2);\n\t\t\t\t\tsetTranslation(t, v3);\n\t\t\t\t\treturn t;\n\t\t\t\t}\n\t\t\t};\n\n\n\t\t\ttemplate\n\t\t\tstruct Create6 {\n\t\t\t\tstatic Type create(const Type2& v0, const Type3& v1, const Type4& v2, const Type5& v3, const Type6& v4, const Type7& v5) {\n\t\t\t\t\tBOOST_MPL_ASSERT((typename VectorTraits::IsVector));\n\t\t\t\t\tType t;\n\t\t\t\t\tget<0>(t) = static_cast::ValueType>(v0);\n\t\t\t\t\tget<1>(t) = static_cast::ValueType>(v1);\n\t\t\t\t\tget<2>(t) = static_cast::ValueType>(v2);\n\t\t\t\t\tget<3>(t) = static_cast::ValueType>(v3);\n\t\t\t\t\tget<4>(t) = static_cast::ValueType>(v4);\n\t\t\t\t\tget<5>(t) = static_cast::ValueType>(v5);\n\t\t\t\t\treturn t;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\n\n\n\t\t/** \n\t\t* \\brief create\n\t\t* \\ingroup openOR_core\n\t\t*/\n\t\ttemplate \n\t\tinline\n\t\t\tOPENOR_CONCEPT_REQUIRES(\n\t\t\t((Concept::Matrix))\n\t\t\t((Concept::ConstVector)),\n\t\t\t(Type))\n\t\t\tcreate(const Vec& vec) {\n\t\t\t\tType mat = MatrixTraits::IDENTITY;\n\t\t\t\tsetTranslation(mat, vec);\n\t\t\t\treturn mat;\n\t\t}\n\n\n\t\t/**\n\t\t* @brief Creation of a vector with two parameters.\n\t\t* @ingroup openOR_core\n\t\t*/\n\t\ttemplate\n\t\tinline Type create(const Type2& v0,\n\t\t\tconst Type3& v1) {\n\t\t\t\treturn Impl::Create2::IsVector>::create(v0, v1);\n\t\t}\n\n\t\t/**\n\t\t* @brief Creation of a vector with three parameters.\n\t\t* @ingroup openOR_core\n\t\t*/\n\t\ttemplate\n\t\tinline Type create(const Type2& v0,\n\t\t\tconst Type3& v1,\n\t\t\tconst Type4& v2) {\n\t\t\t\treturn Impl::Create3::IsVector>::create(v0, v1, v2);\n\t\t}\n\n\n\t\t/**\n\t\t* @brief Creation of a vector with four parameters.\n\t\t* @ingroup openOR_core\n\t\t*/\n\t\ttemplate\n\t\tinline Type create(const Type2& v0, const Type3& v1, const Type4& v2, const Type5& v3) {\n\t\t\treturn Impl::Create4::IsVector>::create(v0, v1, v2, v3);\n\t\t}\n\n\n\t\t/**\n\t\t* @brief Creation of a vector with six parameters.\n\t\t* @ingroup openOR_core\n\t\t*/\n\t\ttemplate\n\t\tinline Type create(const Type2& v0, const Type3& v1, const Type4& v2, const Type5& v3, const Type6& v4, const Type7& v5) {\n\t\t\treturn Impl::Create6::IsVector>::create(v0, v1, v2, v3, v4, v5);\n\t\t}\n\n\n\n\t}\n}\n\n\n#endif\n", "meta": {"hexsha": "9f381bd0c0559e0f823bd6da184d4f82e56d5c45", "size": 8471, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/core/include/openOR/Math/create.hpp", "max_stars_repo_name": "avinfinity/UnmanagedCodeSnippets", "max_stars_repo_head_hexsha": "2bd848db88d7b271209ad30017c8f62307319be3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/core/include/openOR/Math/create.hpp", "max_issues_repo_name": "avinfinity/UnmanagedCodeSnippets", "max_issues_repo_head_hexsha": "2bd848db88d7b271209ad30017c8f62307319be3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/core/include/openOR/Math/create.hpp", "max_forks_repo_name": "avinfinity/UnmanagedCodeSnippets", "max_forks_repo_head_hexsha": "2bd848db88d7b271209ad30017c8f62307319be3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.1459074733, "max_line_length": 143, "alphanum_fraction": 0.6347538661, "num_tokens": 2491, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6039318337259584, "lm_q2_score": 0.5774953651858118, "lm_q1q2_score": 0.3487678348649093}} {"text": "// Copyright 2004, 2005 The Trustees of Indiana University.\n\n// Use, modification and distribution is subject to the Boost Software\n// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// Authors: Nick Edmonds\n// Andrew Lumsdaine\n#ifndef BOOST_GRAPH_RMAT_GENERATOR_HPP\n#define BOOST_GRAPH_RMAT_GENERATOR_HPP\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n// #include \n\nusing boost::shared_ptr;\nusing boost::uniform_01;\n\n// Returns floor(log_2(n)), and -1 when n is 0\ntemplate \ninline int int_log2(IntegerType n) {\n int l = 0;\n while (n > 0) {++l; n >>= 1;}\n return l - 1;\n}\n\nstruct keep_all_edges {\n template \n bool operator()(const T&, const T&) { return true; }\n};\n\ntemplate \nstruct keep_local_edges {\n\n keep_local_edges(const Distribution& distrib, const ProcessId& id)\n : distrib(distrib), id(id)\n { }\n\n template \n bool operator()(const T& x, const T& y)\n { return distrib(x) == id || distrib(y) == id; }\n\nprivate:\n const Distribution& distrib;\n const ProcessId& id;\n};\n\ntemplate \nvoid\ngenerate_permutation_vector(RandomGenerator& gen, std::vector& vertexPermutation, T n)\n{\n using boost::uniform_int;\n\n vertexPermutation.resize(n);\n\n // Generate permutation map of vertex numbers\n uniform_int rand_vertex(0, n-1);\n for (T i = 0; i < n; ++i)\n vertexPermutation[i] = i;\n\n // Can't use std::random_shuffle unless we create another (synchronized) PRNG\n for (T i = 0; i < n; ++i)\n std::swap(vertexPermutation[i], vertexPermutation[rand_vertex(gen)]);\n}\n\ntemplate \nstd::pair\ngenerate_edge(shared_ptr > prob, T n,\n unsigned int SCALE, double a, double b, double c, double d)\n{\n T u = 0, v = 0;\n T step = n/2;\n for (unsigned int j = 0; j < SCALE; ++j) {\n double p = (*prob)();\n\n if (p < a)\n ;\n else if (p >= a && p < a + b)\n v += step;\n else if (p >= a + b && p < a + b + c)\n u += step;\n else { // p > a + b + c && p < a + b + c + d\n u += step;\n v += step;\n }\n\n step /= 2;\n\n // 0.2 and 0.9 are hardcoded in the reference SSCA implementation.\n // The maximum change in any given value should be less than 10%\n a *= 0.9 + 0.2 * (*prob)();\n b *= 0.9 + 0.2 * (*prob)();\n c *= 0.9 + 0.2 * (*prob)();\n d *= 0.9 + 0.2 * (*prob)();\n\n double S = a + b + c + d;\n\n a /= S; b /= S; c /= S;\n // d /= S;\n // Ensure all values add up to 1, regardless of floating point errors\n d = 1. - a - b - c;\n }\n\n return std::make_pair(u, v);\n}\n\nnamespace boost {\n\n /*\n Chakrabarti's R-MAT scale free generator.\n\n For all flavors of the R-MAT iterator a+b+c+d must equal 1 and for the\n unique_rmat_iterator 'm' << 'n^2'. If 'm' is too close to 'n^2' the\n generator may be unable to generate sufficient unique edges\n\n To get a true scale free distribution {a, b, c, d : a > b, a > c, a > d}\n */\n\n template\n class rmat_iterator\n {\n typedef typename graph_traits::directed_category directed_category;\n typedef typename graph_traits::vertices_size_type vertices_size_type;\n typedef typename graph_traits::edges_size_type edges_size_type;\n\n public:\n typedef std::input_iterator_tag iterator_category;\n typedef std::pair value_type;\n typedef const value_type& reference;\n typedef const value_type* pointer;\n typedef std::ptrdiff_t difference_type; // Not used\n\n // No argument constructor, set to terminating condition\n rmat_iterator()\n : gen(), edge(0) { }\n\n // Initialize for edge generation\n rmat_iterator(RandomGenerator& gen, vertices_size_type n,\n edges_size_type m, double a, double b, double c,\n double d, bool permute_vertices = true)\n : gen(), n(n), a(a), b(b), c(c), d(d), edge(m),\n permute_vertices(permute_vertices),\n SCALE(int_log2(n))\n\n {\n this->gen.reset(new uniform_01(gen));\n\n // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c + d, 1., 1.e-5));\n\n if (permute_vertices)\n generate_permutation_vector(gen, vertexPermutation, n);\n\n // TODO: Generate the entire adjacency matrix then \"Clip and flip\" if undirected graph\n\n // Generate the first edge\n vertices_size_type u, v;\n boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);\n\n if (permute_vertices)\n current = std::make_pair(vertexPermutation[u],\n vertexPermutation[v]);\n else\n current = std::make_pair(u, v);\n\n --edge;\n }\n\n reference operator*() const { return current; }\n pointer operator->() const { return ¤t; }\n\n rmat_iterator& operator++()\n {\n vertices_size_type u, v;\n boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);\n\n if (permute_vertices)\n current = std::make_pair(vertexPermutation[u],\n vertexPermutation[v]);\n else\n current = std::make_pair(u, v);\n\n --edge;\n\n return *this;\n }\n\n rmat_iterator operator++(int)\n {\n rmat_iterator temp(*this);\n ++(*this);\n return temp;\n }\n\n bool operator==(const rmat_iterator& other) const\n {\n return edge == other.edge;\n }\n\n bool operator!=(const rmat_iterator& other) const\n { return !(*this == other); }\n\n private:\n\n // Parameters\n shared_ptr > gen;\n vertices_size_type n;\n double a, b, c, d;\n int edge;\n bool permute_vertices;\n int SCALE;\n\n // Internal data structures\n std::vector vertexPermutation;\n value_type current;\n };\n\n // Sorted version for CSR\n template \n struct sort_pair {\n bool operator() (const std::pair& x, const std::pair& y)\n {\n if (x.first == y.first)\n return x.second > y.second;\n else\n return x.first > y.first;\n }\n };\n\n template\n class sorted_rmat_iterator\n {\n typedef typename graph_traits::directed_category directed_category;\n typedef typename graph_traits::vertices_size_type vertices_size_type;\n typedef typename graph_traits::edges_size_type edges_size_type;\n\n public:\n typedef std::input_iterator_tag iterator_category;\n typedef std::pair value_type;\n typedef const value_type& reference;\n typedef const value_type* pointer;\n typedef std::ptrdiff_t difference_type; // Not used\n\n // No argument constructor, set to terminating condition\n sorted_rmat_iterator()\n : gen(), values(sort_pair()), done(true)\n { }\n\n // Initialize for edge generation\n sorted_rmat_iterator(RandomGenerator& gen, vertices_size_type n,\n edges_size_type m, double a, double b, double c,\n double d, bool permute_vertices = true,\n EdgePredicate ep = keep_all_edges())\n : gen(), permute_vertices(permute_vertices),\n values(sort_pair()), done(false)\n\n {\n // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c + d, 1., 1.e-5));\n\n this->gen.reset(new uniform_01(gen));\n\n std::vector vertexPermutation;\n if (permute_vertices)\n generate_permutation_vector(gen, vertexPermutation, n);\n\n // TODO: \"Clip and flip\" if undirected graph\n int SCALE = int_log2(n);\n\n for (edges_size_type i = 0; i < m; ++i) {\n\n vertices_size_type u, v;\n boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);\n\n if (permute_vertices) {\n if (ep(vertexPermutation[u], vertexPermutation[v]))\n values.push(std::make_pair(vertexPermutation[u], vertexPermutation[v]));\n } else {\n if (ep(u, v))\n values.push(std::make_pair(u, v));\n }\n\n }\n\n current = values.top();\n values.pop();\n }\n\n reference operator*() const { return current; }\n pointer operator->() const { return ¤t; }\n\n sorted_rmat_iterator& operator++()\n {\n if (!values.empty()) {\n current = values.top();\n values.pop();\n } else\n done = true;\n\n return *this;\n }\n\n sorted_rmat_iterator operator++(int)\n {\n sorted_rmat_iterator temp(*this);\n ++(*this);\n return temp;\n }\n\n bool operator==(const sorted_rmat_iterator& other) const\n {\n return values.empty() && other.values.empty() && done && other.done;\n }\n\n bool operator!=(const sorted_rmat_iterator& other) const\n { return !(*this == other); }\n\n private:\n\n // Parameters\n shared_ptr > gen;\n bool permute_vertices;\n\n // Internal data structures\n std::priority_queue, sort_pair > values;\n value_type current;\n bool done;\n };\n\n\n // This version is slow but guarantees unique edges\n template\n class unique_rmat_iterator\n {\n typedef typename graph_traits::directed_category directed_category;\n typedef typename graph_traits::vertices_size_type vertices_size_type;\n typedef typename graph_traits::edges_size_type edges_size_type;\n\n public:\n typedef std::input_iterator_tag iterator_category;\n typedef std::pair value_type;\n typedef const value_type& reference;\n typedef const value_type* pointer;\n typedef std::ptrdiff_t difference_type; // Not used\n\n // No argument constructor, set to terminating condition\n unique_rmat_iterator()\n : gen(), done(true)\n { }\n\n // Initialize for edge generation\n unique_rmat_iterator(RandomGenerator& gen, vertices_size_type n,\n edges_size_type m, double a, double b, double c,\n double d, bool permute_vertices = true,\n EdgePredicate ep = keep_all_edges())\n : gen(), done(false)\n\n {\n // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c + d, 1., 1.e-5));\n\n this->gen.reset(new uniform_01(gen));\n\n std::vector vertexPermutation;\n if (permute_vertices)\n generate_permutation_vector(gen, vertexPermutation, n);\n\n int SCALE = int_log2(n);\n\n std::map edge_map;\n\n edges_size_type edges = 0;\n do {\n vertices_size_type u, v;\n boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);\n\n // Lowest vertex number always comes first\n // (this means we don't have to worry about i->j and j->i being in the edge list)\n if (u > v && is_same::value)\n std::swap(u, v);\n\n if (edge_map.find(std::make_pair(u, v)) == edge_map.end()) {\n edge_map[std::make_pair(u, v)] = true;\n\n if (permute_vertices) {\n if (ep(vertexPermutation[u], vertexPermutation[v]))\n values.push_back(std::make_pair(vertexPermutation[u], vertexPermutation[v]));\n } else {\n if (ep(u, v))\n values.push_back(std::make_pair(u, v));\n }\n\n edges++;\n }\n } while (edges < m);\n // NGE - Asking for more than n^2 edges will result in an infinite loop here\n // Asking for a value too close to n^2 edges may as well\n\n current = values.back();\n values.pop_back();\n }\n\n reference operator*() const { return current; }\n pointer operator->() const { return ¤t; }\n\n unique_rmat_iterator& operator++()\n {\n if (!values.empty()) {\n current = values.back();\n values.pop_back();\n } else\n done = true;\n\n return *this;\n }\n\n unique_rmat_iterator operator++(int)\n {\n unique_rmat_iterator temp(*this);\n ++(*this);\n return temp;\n }\n\n bool operator==(const unique_rmat_iterator& other) const\n {\n return values.empty() && other.values.empty() && done && other.done;\n }\n\n bool operator!=(const unique_rmat_iterator& other) const\n { return !(*this == other); }\n\n private:\n\n // Parameters\n shared_ptr > gen;\n\n // Internal data structures\n std::vector values;\n value_type current;\n bool done;\n };\n\n // This version is slow but guarantees unique edges\n template\n class sorted_unique_rmat_iterator\n {\n typedef typename graph_traits::directed_category directed_category;\n typedef typename graph_traits::vertices_size_type vertices_size_type;\n typedef typename graph_traits::edges_size_type edges_size_type;\n\n public:\n typedef std::input_iterator_tag iterator_category;\n typedef std::pair value_type;\n typedef const value_type& reference;\n typedef const value_type* pointer;\n typedef std::ptrdiff_t difference_type; // Not used\n\n // No argument constructor, set to terminating condition\n sorted_unique_rmat_iterator()\n : gen(), values(sort_pair()), done(true) { }\n\n // Initialize for edge generation\n sorted_unique_rmat_iterator(RandomGenerator& gen, vertices_size_type n,\n edges_size_type m, double a, double b, double c,\n double d, bool bidirectional = false,\n bool permute_vertices = true,\n EdgePredicate ep = keep_all_edges())\n : gen(), bidirectional(bidirectional),\n values(sort_pair()), done(false)\n\n {\n // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c + d, 1., 1.e-5));\n\n this->gen.reset(new uniform_01(gen));\n\n std::vector vertexPermutation;\n if (permute_vertices)\n generate_permutation_vector(gen, vertexPermutation, n);\n\n int SCALE = int_log2(n);\n\n std::map edge_map;\n\n edges_size_type edges = 0;\n do {\n\n vertices_size_type u, v;\n boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);\n\n if (bidirectional) {\n if (edge_map.find(std::make_pair(u, v)) == edge_map.end()) {\n edge_map[std::make_pair(u, v)] = true;\n edge_map[std::make_pair(v, u)] = true;\n\n if (ep(u, v)) {\n if (permute_vertices) {\n values.push(std::make_pair(vertexPermutation[u], vertexPermutation[v]));\n values.push(std::make_pair(vertexPermutation[v], vertexPermutation[u]));\n } else {\n values.push(std::make_pair(u, v));\n values.push(std::make_pair(v, u));\n }\n }\n\n ++edges;\n }\n } else {\n // Lowest vertex number always comes first\n // (this means we don't have to worry about i->j and j->i being in the edge list)\n if (u > v && is_same::value)\n std::swap(u, v);\n\n if (edge_map.find(std::make_pair(u, v)) == edge_map.end()) {\n edge_map[std::make_pair(u, v)] = true;\n\n if (permute_vertices) {\n if (ep(vertexPermutation[u], vertexPermutation[v]))\n values.push(std::make_pair(vertexPermutation[u], vertexPermutation[v]));\n } else {\n if (ep(u, v))\n values.push(std::make_pair(u, v));\n }\n\n ++edges;\n }\n }\n\n } while (edges < m);\n // NGE - Asking for more than n^2 edges will result in an infinite loop here\n // Asking for a value too close to n^2 edges may as well\n\n current = values.top();\n values.pop();\n }\n\n reference operator*() const { return current; }\n pointer operator->() const { return ¤t; }\n\n sorted_unique_rmat_iterator& operator++()\n {\n if (!values.empty()) {\n current = values.top();\n values.pop();\n } else\n done = true;\n\n return *this;\n }\n\n sorted_unique_rmat_iterator operator++(int)\n {\n sorted_unique_rmat_iterator temp(*this);\n ++(*this);\n return temp;\n }\n\n bool operator==(const sorted_unique_rmat_iterator& other) const\n {\n return values.empty() && other.values.empty() && done && other.done;\n }\n\n bool operator!=(const sorted_unique_rmat_iterator& other) const\n { return !(*this == other); }\n\n private:\n\n // Parameters\n shared_ptr > gen;\n bool bidirectional;\n\n // Internal data structures\n std::priority_queue,\n sort_pair > values;\n value_type current;\n bool done;\n };\n\n} // end namespace boost\n\n#include BOOST_GRAPH_MPI_INCLUDE()\n\n#endif // BOOST_GRAPH_RMAT_GENERATOR_HPP\n", "meta": {"hexsha": "a96887fbd6cafc2fefb65ff5ebc39ef599831c37", "size": 17942, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "boost/graph/rmat_graph_generator.hpp", "max_stars_repo_name": "cpp-pm/boost", "max_stars_repo_head_hexsha": "38c6c8c07f2fcc42d573b10807fef27ec14930f8", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 12278.0, "max_stars_repo_stars_event_min_datetime": "2015-01-29T17:11:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T21:12:00.000Z", "max_issues_repo_path": "boost/graph/rmat_graph_generator.hpp", "max_issues_repo_name": "cpp-pm/boost", "max_issues_repo_head_hexsha": "38c6c8c07f2fcc42d573b10807fef27ec14930f8", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 9469.0, "max_issues_repo_issues_event_min_datetime": "2015-01-30T05:33:07.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T16:17:21.000Z", "max_forks_repo_path": "boost/graph/rmat_graph_generator.hpp", "max_forks_repo_name": "cpp-pm/boost", "max_forks_repo_head_hexsha": "38c6c8c07f2fcc42d573b10807fef27ec14930f8", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 892.0, "max_forks_repo_forks_event_min_datetime": "2015-01-29T16:26:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-20T07:44:30.000Z", "avg_line_length": 30.1546218487, "max_line_length": 100, "alphanum_fraction": 0.6238992309, "num_tokens": 4362, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6039318337259584, "lm_q2_score": 0.5774953651858117, "lm_q1q2_score": 0.34876783486490925}} {"text": "\r\n\r\n#include \r\n#include \r\n\r\n#include \r\n\r\n\r\nNTL_START_IMPL\r\n\r\n\r\n\r\nNTL_THREAD_LOCAL SmartPtr ZZ_pInfo = 0;\r\nNTL_THREAD_LOCAL SmartPtr ZZ_pTmpSpace = 0;\r\nNTL_THREAD_LOCAL bool ZZ_pInstalled = false;\r\n\r\n\r\n\r\nZZ_pInfoT::ZZ_pInfoT(const ZZ& NewP)\r\n{\r\n if (NewP <= 1) LogicError(\"ZZ_pContext: p must be > 1\");\r\n\r\n p = NewP;\r\n size = p.size();\r\n\r\n ExtendedModulusSize = 2*size + \r\n (NTL_BITS_PER_LONG + NTL_ZZ_NBITS - 1)/NTL_ZZ_NBITS;\r\n\r\n}\r\n\r\n\r\n\r\n// we use a lazy strategy for initializing and installing\r\n// FFTInfo and TmpSpace related to a ZZ_p modulus. \r\n// The routines GetFFTInfo and GetTmpSpace make sure this process \r\n// is complete.\r\n\r\nvoid ZZ_p::DoInstall()\r\n{\r\n SmartPtr tmps = 0;\r\n\r\n do { // NOTE: thread safe lazy init \r\n Lazy::Builder builder(ZZ_pInfo->FFTInfo);\r\n if (!builder()) break;\r\n\r\n UniquePtr FFTInfo;\r\n FFTInfo.make();\r\n\r\n ZZ B, M, M1, M2, M3;\r\n long n, i;\r\n long q, t;\r\n\r\n sqr(B, ZZ_pInfo->p);\r\n\r\n LeftShift(B, B, NTL_FFTMaxRoot+NTL_FFTFudge);\r\n\r\n // FIXME: the following is quadratic time...would\r\n // be nice to get a faster solution...\r\n // One could estimate the # of primes by summing logs,\r\n // then multiply using a tree-based multiply, then \r\n // adjust up or down...\r\n\r\n // Assuming IEEE floating point, the worst case estimate\r\n // for error guarantees a correct answer +/- 1 for\r\n // numprimes up to 2^25...for sure we won't be\r\n // using that many primes...we can certainly put in \r\n // a sanity check, though. \r\n\r\n // If I want a more accuaruate summation (with using Kahan,\r\n // which has some portability issues), I could represent \r\n // numbers as x = a + f, where a is integer and f is the fractional\r\n // part. Summing in this representation introduces an *absolute*\r\n // error of 2 epsilon n, which is just as good as Kahan \r\n // for this application.\r\n\r\n // same strategy could also be used in the ZZX HomMul routine,\r\n // if we ever want to make that subquadratic\r\n\r\n set(M);\r\n n = 0;\r\n while (M <= B) {\r\n UseFFTPrime(n);\r\n q = GetFFTPrime(n);\r\n n++;\r\n mul(M, M, q);\r\n }\r\n\r\n FFTInfo->NumPrimes = n;\r\n FFTInfo->MaxRoot = CalcMaxRoot(q);\r\n\r\n\r\n double fn = double(n);\r\n\r\n if (8.0*fn*(fn+32) > NTL_FDOUBLE_PRECISION)\r\n ResourceError(\"modulus too big\");\r\n\r\n\r\n if (8.0*fn*(fn+32) > NTL_FDOUBLE_PRECISION/double(NTL_SP_BOUND))\r\n FFTInfo->QuickCRT = false;\r\n else\r\n FFTInfo->QuickCRT = true;\r\n\r\n\r\n FFTInfo->x.SetLength(n);\r\n FFTInfo->u.SetLength(n);\r\n\r\n FFTInfo->rem_struct.init(n, ZZ_pInfo->p, GetFFTPrime);\r\n\r\n FFTInfo->crt_struct.init(n, ZZ_pInfo->p, GetFFTPrime);\r\n\r\n if (!FFTInfo->crt_struct.special()) {\r\n ZZ qq, rr;\r\n\r\n DivRem(qq, rr, M, ZZ_pInfo->p);\r\n\r\n NegateMod(FFTInfo->MinusMModP, rr, ZZ_pInfo->p);\r\n\r\n for (i = 0; i < n; i++) {\r\n q = GetFFTPrime(i);\r\n\r\n long tt = rem(qq, q);\r\n\r\n mul(M2, ZZ_pInfo->p, tt);\r\n add(M2, M2, rr); \r\n div(M2, M2, q); // = (M/q) rem p\r\n \r\n\r\n div(M1, M, q);\r\n t = rem(M1, q);\r\n t = InvMod(t, q);\r\n\r\n mul(M3, M2, t);\r\n rem(M3, M3, ZZ_pInfo->p);\r\n\r\n FFTInfo->crt_struct.insert(i, M3);\r\n\r\n\r\n FFTInfo->x[i] = ((double) t)/((double) q);\r\n FFTInfo->u[i] = t;\r\n }\r\n }\r\n\r\n tmps = MakeSmart();\r\n tmps->crt_tmp_vec.fetch(FFTInfo->crt_struct);\r\n tmps->rem_tmp_vec.fetch(FFTInfo->rem_struct);\r\n\r\n builder.move(FFTInfo);\r\n } while (0);\r\n\r\n if (!tmps) {\r\n const ZZ_pFFTInfoT *FFTInfo = ZZ_pInfo->FFTInfo.get();\r\n tmps = MakeSmart();\r\n tmps->crt_tmp_vec.fetch(FFTInfo->crt_struct);\r\n tmps->rem_tmp_vec.fetch(FFTInfo->rem_struct);\r\n }\r\n\r\n ZZ_pTmpSpace = tmps;\r\n}\r\n\r\n\r\n\r\n\r\nvoid ZZ_p::init(const ZZ& p)\r\n{\r\n ZZ_pContext c(p);\r\n c.restore();\r\n}\r\n\r\n\r\n\r\nvoid ZZ_pContext::restore() const\r\n{\r\n ZZ_pInfo = ptr;\r\n ZZ_pTmpSpace = 0;\r\n ZZ_pInstalled = false;\r\n}\r\n\r\n\r\n\r\nZZ_pBak::~ZZ_pBak()\r\n{\r\n if (MustRestore) c.restore();\r\n}\r\n\r\nvoid ZZ_pBak::save()\r\n{\r\n c.save();\r\n MustRestore = true;\r\n}\r\n\r\n\r\nvoid ZZ_pBak::restore()\r\n{\r\n c.restore();\r\n MustRestore = false;\r\n}\r\n\r\n\r\nconst ZZ_p& ZZ_p::zero()\r\n{\r\n NTL_THREAD_LOCAL static ZZ_p z(INIT_NO_ALLOC);\r\n return z;\r\n}\r\n\r\nNTL_THREAD_LOCAL\r\nZZ_p::DivHandlerPtr ZZ_p::DivHandler = 0;\r\n\r\n \r\n\r\nZZ_p::ZZ_p(INIT_VAL_TYPE, const ZZ& a) // NO_ALLOC\r\n{\r\n conv(*this, a);\r\n} \r\n\r\nZZ_p::ZZ_p(INIT_VAL_TYPE, long a) // NO_ALLOC\r\n{\r\n conv(*this, a);\r\n}\r\n\r\n\r\nvoid conv(ZZ_p& x, long a)\r\n{\r\n if (a == 0)\r\n clear(x);\r\n else if (a == 1)\r\n set(x);\r\n else {\r\n NTL_ZZRegister(y);\r\n\r\n conv(y, a);\r\n conv(x, y);\r\n }\r\n}\r\n\r\nistream& operator>>(istream& s, ZZ_p& x)\r\n{\r\n NTL_ZZRegister(y);\r\n\r\n NTL_INPUT_CHECK_RET(s, s >> y);\r\n conv(x, y);\r\n\r\n return s;\r\n}\r\n\r\nvoid div(ZZ_p& x, const ZZ_p& a, const ZZ_p& b)\r\n{\r\n NTL_ZZ_pRegister(T);\r\n\r\n inv(T, b);\r\n mul(x, a, T);\r\n}\r\n\r\nvoid inv(ZZ_p& x, const ZZ_p& a)\r\n{\r\n NTL_ZZRegister(T);\r\n\r\n if (InvModStatus(T, a._ZZ_p__rep, ZZ_p::modulus())) {\r\n if (!IsZero(a._ZZ_p__rep) && ZZ_p::DivHandler)\r\n (*ZZ_p::DivHandler)(a);\r\n\r\n InvModError(\"ZZ_p: division by non-invertible element\",\r\n a._ZZ_p__rep, ZZ_p::modulus());\r\n }\r\n\r\n x._ZZ_p__rep = T;\r\n}\r\n\r\nlong operator==(const ZZ_p& a, long b)\r\n{\r\n if (b == 0)\r\n return IsZero(a);\r\n\r\n if (b == 1)\r\n return IsOne(a);\r\n\r\n NTL_ZZ_pRegister(T);\r\n conv(T, b);\r\n return a == T;\r\n}\r\n\r\n\r\n\r\nvoid add(ZZ_p& x, const ZZ_p& a, long b)\r\n{\r\n NTL_ZZ_pRegister(T);\r\n conv(T, b);\r\n add(x, a, T);\r\n}\r\n\r\nvoid sub(ZZ_p& x, const ZZ_p& a, long b)\r\n{\r\n NTL_ZZ_pRegister(T);\r\n conv(T, b);\r\n sub(x, a, T);\r\n}\r\n\r\nvoid sub(ZZ_p& x, long a, const ZZ_p& b)\r\n{\r\n NTL_ZZ_pRegister(T);\r\n conv(T, a);\r\n sub(x, T, b);\r\n}\r\n\r\nvoid mul(ZZ_p& x, const ZZ_p& a, long b)\r\n{\r\n NTL_ZZ_pRegister(T);\r\n conv(T, b);\r\n mul(x, a, T);\r\n}\r\n\r\nvoid div(ZZ_p& x, const ZZ_p& a, long b)\r\n{\r\n NTL_ZZ_pRegister(T);\r\n conv(T, b);\r\n div(x, a, T);\r\n}\r\n\r\nvoid div(ZZ_p& x, long a, const ZZ_p& b)\r\n{\r\n if (a == 1) {\r\n inv(x, b);\r\n }\r\n else {\r\n NTL_ZZ_pRegister(T);\r\n conv(T, a);\r\n div(x, T, b);\r\n }\r\n}\r\n\r\nNTL_END_IMPL\r\n", "meta": {"hexsha": "3a20a886cbda43f771061d4bd4270e4567ad4f7c", "size": 6578, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "WinNTL-8_1_2/src/ZZ_p.cpp", "max_stars_repo_name": "Brainloop-Security/secret-sharing", "max_stars_repo_head_hexsha": "56cd3bc808c666b653cbe2b2a5fb2cb9fe760cdd", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "WinNTL-8_1_2/src/ZZ_p.cpp", "max_issues_repo_name": "Brainloop-Security/secret-sharing", "max_issues_repo_head_hexsha": "56cd3bc808c666b653cbe2b2a5fb2cb9fe760cdd", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "WinNTL-8_1_2/src/ZZ_p.cpp", "max_forks_repo_name": "Brainloop-Security/secret-sharing", "max_forks_repo_head_hexsha": "56cd3bc808c666b653cbe2b2a5fb2cb9fe760cdd", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 19.8731117825, "max_line_length": 74, "alphanum_fraction": 0.5442383703, "num_tokens": 2012, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.34876783486490925}} {"text": "/**\n * @file SimPolygon2D.cpp\n * @author Alex Cunningham\n */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n\nnamespace gtsam {\n\nusing namespace std;\n\nconst size_t max_it = 100000;\nboost::minstd_rand SimPolygon2D::rng(42u);\n\n/* ************************************************************************* */\nvoid SimPolygon2D::seedGenerator(unsigned long seed) {\n rng = boost::minstd_rand(seed);\n}\n\n/* ************************************************************************* */\nSimPolygon2D SimPolygon2D::createTriangle(const Point2& pA, const Point2& pB, const Point2& pC) {\n SimPolygon2D result;\n result.landmarks_.push_back(pA);\n result.landmarks_.push_back(pB);\n result.landmarks_.push_back(pC);\n return result;\n}\n\n/* ************************************************************************* */\nSimPolygon2D SimPolygon2D::createRectangle(const Point2& p, double height, double width) {\n SimPolygon2D result;\n result.landmarks_.push_back(p);\n result.landmarks_.push_back(p + Point2(width, 0.0));\n result.landmarks_.push_back(p + Point2(width, height));\n result.landmarks_.push_back(p + Point2(0.0, height));\n return result;\n}\n\n/* ************************************************************************* */\nbool SimPolygon2D::equals(const SimPolygon2D& p, double tol) const {\n if (p.size() != size()) return false;\n for (size_t i=0; i::Equals(landmarks_[i], p.landmarks_[i], tol))\n return false;\n return true;\n}\n\n/* ************************************************************************* */\nvoid SimPolygon2D::print(const string& s) const {\n cout << \"SimPolygon \" << s << \": \" << endl;\n for(const Point2& p: landmarks_)\n traits::Print(p, \" \");\n}\n\n/* ************************************************************************* */\nvector SimPolygon2D::walls() const {\n vector result;\n for (size_t i=0; i edges = walls();\n bool initialized = false;\n bool lastSide = false;\n for(const SimWall2D& ab: edges) {\n // compute cross product of ab and ac\n Point2 dab = ab.b() - ab.a();\n Point2 dac = c - ab.a();\n double cross = dab.x() * dac.y() - dab.y() * dac.x();\n if (fabs(cross) < 1e-6) // check for on one of the edges\n return true;\n bool side = cross > 0;\n // save the first side found\n if (!initialized) {\n lastSide = side;\n initialized = true;\n continue;\n }\n\n // to be inside the polygon, point must be on the same side of all lines\n if (lastSide != side)\n return false;\n }\n return true;\n}\n\n/* ************************************************************************* */\nbool SimPolygon2D::overlaps(const SimPolygon2D& p) const {\n for(const Point2& a: landmarks_)\n if (p.contains(a))\n return true;\n for(const Point2& a: p.landmarks_)\n if (contains(a))\n return true;\n return false;\n}\n\n/* ***************************************************************** */\nbool SimPolygon2D::anyContains(const Point2& p, const vector& obstacles) {\n for(const SimPolygon2D& poly: obstacles)\n if (poly.contains(p))\n return true;\n return false;\n}\n\n/* ************************************************************************* */\nbool SimPolygon2D::anyOverlaps(const SimPolygon2D& p, const vector& obstacles) {\n for(const SimPolygon2D& poly: obstacles)\n if (poly.overlaps(p))\n return true;\n return false;\n}\n\n/* ************************************************************************* */\nSimPolygon2D SimPolygon2D::randomTriangle(\n double side_len, double mean_side_len, double sigma_side_len,\n double min_vertex_dist, double min_side_len, const vector& existing_polys) {\n // get the current set of landmarks\n std::vector lms;\n double d2 = side_len/2.0;\n lms.push_back(Point2( d2, d2));\n lms.push_back(Point2(-d2, d2));\n lms.push_back(Point2(-d2,-d2));\n lms.push_back(Point2( d2,-d2));\n\n for(const SimPolygon2D& poly: existing_polys)\n lms.insert(lms.begin(), poly.vertices().begin(), poly.vertices().end());\n\n for (size_t i=0; i dAC) && // triangle inequality\n (dAB + dAC + thresh > dBC) &&\n (dAC + dBC + thresh > dAB) &&\n insideBox(side_len, test_tri.landmark(0)) &&\n insideBox(side_len, test_tri.landmark(1)) &&\n insideBox(side_len, test_tri.landmark(2)) &&\n distance2(test_tri.landmark(1), test_tri.landmark(2)) > min_side_len &&\n !nearExisting(lms, test_tri.landmark(0), min_vertex_dist) &&\n !nearExisting(lms, test_tri.landmark(1), min_vertex_dist) &&\n !nearExisting(lms, test_tri.landmark(2), min_vertex_dist) &&\n !anyOverlaps(test_tri, existing_polys)) {\n return test_tri;\n }\n }\n throw runtime_error(\"Could not find space for a triangle\");\n return SimPolygon2D::createTriangle(Point2(99,99), Point2(99,99), Point2(99,99));\n}\n\n/* ************************************************************************* */\nSimPolygon2D SimPolygon2D::randomRectangle(\n double side_len, double mean_side_len, double sigma_side_len,\n double min_vertex_dist, double min_side_len, const vector& existing_polys) {\n // get the current set of landmarks\n std::vector lms;\n double d2 = side_len/2.0;\n lms.push_back(Point2( d2, d2));\n lms.push_back(Point2(-d2, d2));\n lms.push_back(Point2(-d2,-d2));\n lms.push_back(Point2( d2,-d2));\n for(const SimPolygon2D& poly: existing_polys)\n lms.insert(lms.begin(), poly.vertices().begin(), poly.vertices().end());\n\n const Point2 lower_corner(-side_len,-side_len);\n const Point2 upper_corner( side_len, side_len);\n\n for (size_t i=0; i gen_t(-s/2.0, s/2.0);\n return Point2(gen_t(rng), gen_t(rng));\n}\n\n/* ***************************************************************** */\nRot2 SimPolygon2D::randomAngle() {\n boost::uniform_real<> gen_r(-M_PI, M_PI); // modified range to avoid degenerate cases in triangles\n return Rot2::fromAngle(gen_r(rng));\n}\n\n/* ***************************************************************** */\ndouble SimPolygon2D::randomDistance(double mu, double sigma, double min_dist) {\n boost::normal_distribution norm_dist(mu, sigma);\n boost::variate_generator > gen_d(rng, norm_dist);\n double d = -10.0;\n for (size_t i=0; i min_dist)\n return d;\n }\n cout << \"Non viable distance: \" << d << \" with mu = \" << mu << \" sigma = \" << sigma\n << \" min_dist = \" << min_dist << endl;\n throw runtime_error(\"Failed to find a viable distance\");\n return fabs(norm_dist(rng));\n}\n\n/* ***************************************************************** */\nPoint2 SimPolygon2D::randomBoundedPoint2(double boundary_size,\n const vector& obstacles) {\n for (size_t i=0; i& landmarks, double min_landmark_dist) {\n for (size_t i=0; i& landmarks,\n const vector& obstacles, double min_landmark_dist) {\n for (size_t i=0; i& landmarks,\n const std::vector& obstacles, double min_landmark_dist) {\n\n boost::uniform_real<> gen_x(0.0, UR_corner.x() - LL_corner.x());\n boost::uniform_real<> gen_y(0.0, UR_corner.y() - LL_corner.y());\n\n for (size_t i=0; i& obstacles) {\n return Pose2(randomAngle(), randomBoundedPoint2(boundary_size, obstacles));\n}\n\n/* ***************************************************************** */\nbool SimPolygon2D::insideBox(double s, const Point2& p) {\n return fabs(p.x()) < s/2.0 && fabs(p.y()) < s/2.0;\n}\n\n/* ***************************************************************** */\nbool SimPolygon2D::nearExisting(const std::vector& S,\n const Point2& p, double threshold) {\n for(const Point2& Sp: S)\n if (distance2(Sp, p) < threshold)\n return true;\n return false;\n}\n\n} //\\namespace gtsam\n\n", "meta": {"hexsha": "ba1445b207d00deecc1378d7434655b9e70e69f3", "size": 12323, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "gtsam_unstable/geometry/SimPolygon2D.cpp", "max_stars_repo_name": "alexhagiopol/GTSAM", "max_stars_repo_head_hexsha": "c397fac199d0202c7abb1cd8e6005731658f56e8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2018-12-19T08:19:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-16T05:22:05.000Z", "max_issues_repo_path": "gtsam_unstable/geometry/SimPolygon2D.cpp", "max_issues_repo_name": "luhongquan66/gtsam", "max_issues_repo_head_hexsha": "c21186c6212798e665da6b5015296713ddfe8c1d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-11-09T06:39:02.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-09T06:39:02.000Z", "max_forks_repo_path": "gtsam_unstable/geometry/SimPolygon2D.cpp", "max_forks_repo_name": "luhongquan66/gtsam", "max_forks_repo_head_hexsha": "c21186c6212798e665da6b5015296713ddfe8c1d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 11.0, "max_forks_repo_forks_event_min_datetime": "2016-08-30T13:14:48.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-12T18:49:58.000Z", "avg_line_length": 37.3424242424, "max_line_length": 107, "alphanum_fraction": 0.5943357949, "num_tokens": 3155, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.603931819468636, "lm_q2_score": 0.5774953651858118, "lm_q1q2_score": 0.34876782663137174}} {"text": "/**\n\n\\file\n\\author Datta Ramadasan\n//==============================================================================\n// Copyright 2015 INSTITUT PASCAL UMR 6602 CNRS/Univ. Clermont II\n//\n// Distributed under the Boost Software License, Version 1.0.\n// See accompanying file LICENSE.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt\n//==============================================================================\n\n*/\n\n#ifndef __OPTIMISATION2_FUNCTION_DERIVATIVE_NUMERICAL_DERIVATIVE_HPP__\n#define __OPTIMISATION2_FUNCTION_DERIVATIVE_NUMERICAL_DERIVATIVE_HPP__\n\n#include \"detail_derivative.hpp\"\n#include \n#include \n#include \n\ntemplate\nstruct Container;\n\nnamespace lma\n{\n //! calcul de dérivée numérique avec déroulage static sur les blocks, puis sur les paramètres de chaque block, puis sur chaque résidu\n\n \n namespace detail\n {\n template struct TupleDerivator;\n template struct TupleDerivator\n {\n template static void compute(const A&, const B&, const C&, const D&){}\n template static void compute(const A&, const B&, const C&){}\n };\n\n template struct TupleDerivatorInternal;\n template struct TupleDerivatorInternal\n {\n template static void compute(const Fonction&, Result&, Tuple&, const R1&){}\n template static void compute(const Fonction&, Result&, Tuple&){}\n };\n\n template struct FinalUnroll\n {\n TIE& tie;\n FinalUnroll(TIE& tie_):tie(tie_){}\n \n template inline void compute(A& a, const Float& b, const Float& c, const D& d) const\n {\n \tstatic_assert( K==0, \"K==0\" );\n \tstd::get(a) = ( b - c ) * d;\n //a(K,I) = ( b - c ) * d;\n }\n\n template inline void compute(A& a, const B& b, const C& c, const D& d) const\n {\n\t //a(K,I) = ( std::get(b) - std::get(c) ) * d;\n std::get(a) = ( std::get(b) - std::get(c) ) * d;\n }\n \n template inline void operator()(Int const &) const\n {\n\t compute(bf::at_c<0>(tie),bf::at_c<1>(tie),bf::at_c<2>(tie),bf::at_c<3>(tie));\n }\n };\n\n template struct TupleDerivatorInternal\n {\n // forward derivative\n template static void compute(const Fonction& fonction, Result& result, Tuple& tuple, const R& r1)\n {\n static const Float h = Float(2.0)*std::sqrt( std::numeric_limits::epsilon() );\n static const Float _h = Float(1.0) / h ;\n //! to_ref : on crée une référence vers l'objet contenu dans le tuple (uniquement pour simplifier l'écriture)\n //! -> to_ref renvoie T& que l'objet contenu soit T ou T*\n //! at -> renvoie at_c(tuple) ou at_c(map).second\n\n auto& ref_objet = ttt::to_ref(bf::at_c(tuple));\n auto& jacob = bf::at_c(result).second;\n\n BOOST_MPL_ASSERT((boost::is_reference));\n assert( (&ref_objet == &ttt::to_ref(bf::at_c(tuple))) );\n\n auto backup = back_up(ref_objet);\n detail::internal_apply_small_increment(ref_objet,h,v::numeric_tag());\n typedef typename Fonction::ErreurType Residu;\n Residu r2;\n bool b2 = fonction(tuple,r2);\n backup.restore();\n\n if(b2) // functor evaluation didn't failed\n {\n auto tie = bf::vector_tie(jacob,r2,r1,_h);\n ttt::unroll<0,Size::value>(FinalUnroll(tie));\n TupleDerivatorInternal::template compute(fonction,result,tuple,r1);\n return;\n }\n\n set_zero(jacob);\n }\n \n // central derivative\n template static void compute(const Fonction& fonction, Result& result, Tuple& tuple)\n {\n static const Float h = Float(2.0)*std::sqrt( std::numeric_limits::epsilon() );\n static const Float _h = Float(1.0) / (2.0*h) ;\n //! to_ref : on crée une référence vers l'objet contenu dans le tuple (uniquement pour simplifier l'écriture)\n //! -> to_ref renvoie T& que l'objet contenu soit T ou T*\n //! at -> renvoie at_c(tuple) ou at_c(map).second\n\n auto& ref_objet = ttt::to_ref(bf::at_c(tuple));\n auto& jacob = bf::at_c(result).second;\n\n BOOST_MPL_ASSERT((boost::is_reference));\n assert( (&ref_objet == &ttt::to_ref(bf::at_c(tuple))) );\n\n typedef typename Fonction::ErreurType Residu;\n Residu r2;\n \n auto backup = back_up(ref_objet);\n detail::internal_apply_small_increment(ref_objet,h,v::numeric_tag());\n bool b2 = fonction(tuple,r2);\n backup.restore();\n if (b2)\n {\n detail::internal_apply_small_increment(ref_objet,-h,v::numeric_tag());\n Residu r1;\n bool b1 = fonction(tuple,r1);\n backup.restore();\n \n if(b1)\n {\n auto tie = bf::vector_tie(jacob,r2,r1,_h);\n ttt::unroll<0,Size::value>(FinalUnroll(tie));\n TupleDerivatorInternal::template compute(fonction,result,tuple);\n return;\n }\n }\n set_zero(jacob);\n }\n };\n\n template struct TupleDerivator\n {\n // numerical central derivative\n template static void compute(const Fonction& fonction, Result& result, Tuple& tuple)\n {\n static const size_t F = Size(tuple)))>::value;\n TupleDerivatorInternal::template compute(fonction,result,tuple);\n TupleDerivator::template compute(fonction,result,tuple);\n }\n\n // numerical foward derivative\n template static void compute(const Fonction& fonction, Result& result, Tuple& tuple, const R1& r1)\n {\n static const size_t F = Size(tuple)))>::value;\n TupleDerivatorInternal::template compute(fonction,result,tuple,r1);\n TupleDerivator::template compute(fonction,result,tuple,r1);\n }\n };\n }// eon detail\n\n\n template struct NumericalDerivator\n {\n //! le tuple en entrée ne doit pas être constant car il sera modifié, et remis à l'état d'origine\n template\n static void derive(const Function& fonctor, Tuple tuple, Jacob& result)\n {\n detail::TupleDerivator::value>::template compute(fonctor,result,tuple);\n }\n\n template\n static void derive(const Function& fonctor, Tuple tuple, Jacob& result, const Residual& residual)\n {\n detail::TupleDerivator::value>::template compute(fonctor,result,tuple,residual);\n }\n };\n\n}// eon\n\nnamespace ttt\n{\n template struct Name> { static std::string name(){ return \"NumericalDerivator<\" + ttt::name() + \">\"; } };\n}\n\n#endif\n\n", "meta": {"hexsha": "22f29ccfc4b2a50a610bd70b9358538bd0d86041", "size": 7866, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/libv/lma/lm/function/derivative/numerical_derivative.hpp", "max_stars_repo_name": "bezout/LMA", "max_stars_repo_head_hexsha": "9555e41eed5f44690c5f6e3ea2d22d520ff1a9d2", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 29.0, "max_stars_repo_stars_event_min_datetime": "2015-12-08T12:07:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-08T21:23:01.000Z", "max_issues_repo_path": "src/libv/lma/lm/function/derivative/numerical_derivative.hpp", "max_issues_repo_name": "ayumizll/LMA", "max_issues_repo_head_hexsha": "e945452e12a8b05bd17400b46a20a5322aeda01d", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2016-07-11T16:23:48.000Z", "max_issues_repo_issues_event_max_datetime": "2017-04-05T13:33:00.000Z", "max_forks_repo_path": "src/libv/lma/lm/function/derivative/numerical_derivative.hpp", "max_forks_repo_name": "bezout/LMA", "max_forks_repo_head_hexsha": "9555e41eed5f44690c5f6e3ea2d22d520ff1a9d2", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2015-12-21T01:52:27.000Z", "max_forks_repo_forks_event_max_datetime": "2017-12-26T02:26:55.000Z", "avg_line_length": 40.7564766839, "max_line_length": 157, "alphanum_fraction": 0.6244597, "num_tokens": 2110, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6334102775181399, "lm_q2_score": 0.5506073655352404, "lm_q1q2_score": 0.3487603642072085}} {"text": "/* Author: Luca Heltai, Cataldo Manigrasso, 2009 */\n\n/* $Id: step-34.cc 28376 2013-02-13 15:19:38Z heister $ */\n/* */\n/* Copyright (C) 2009-2012 by deal.II authors */\n/* */\n/* This file is subject to QPL and may not be distributed */\n/* without copyright and license information. Please refer */\n/* to the file deal.II/doc/license.html for the text and */\n/* further information on this license. */\n\n// @sect3{Include files}\n\n// The program starts with including a bunch of include files that we will use\n// in the various parts of the program. Most of them have been discussed in\n// previous tutorials already:\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \n#include \n\n// And here are a few C++ standard header files that we will need:\n#include \n#include \n#include \n#include \n\n// The last part of this preamble is to import everything in the dealii\n// namespace into the one into which everything in this program will go:\nnamespace Step34\n{\n using namespace dealii;\n\n\n // @sect3{Single and double layer operator kernels}\n\n // First, let us define a bit of the boundary integral equation machinery.\n\n // The following two functions are the actual calculations of the single and\n // double layer potential kernels, that is $G$ and $\\nabla G$. They are well\n // defined only if the vector $R = \\mathbf{y}-\\mathbf{x}$ is different from\n // zero.\n namespace LaplaceKernel\n {\n template \n double single_layer(const Point &R)\n {\n switch (dim)\n {\n case 2:\n return (-std::log(R.norm()) / (2*numbers::PI) );\n\n case 3:\n return (1./( R.norm()*4*numbers::PI ) );\n\n default:\n Assert(false, ExcInternalError());\n return 0.;\n }\n }\n\n\n\n template \n Point double_layer(const Point &R)\n {\n switch (dim)\n {\n case 2:\n return R / ( -2*numbers::PI * R.square());\n case 3:\n return R / ( -4*numbers::PI * R.square() * R.norm() );\n\n default:\n Assert(false, ExcInternalError());\n return Point();\n }\n }\n }\n\n\n // @sect3{The BEMProblem class}\n\n // The structure of a boundary element method code is very similar to the\n // structure of a finite element code, and so the member functions of this\n // class are like those of most of the other tutorial programs. In\n // particular, by now you should be familiar with reading parameters from an\n // external file, and with the splitting of the different tasks into\n // different modules. The same applies to boundary element methods, and we\n // won't comment too much on them, except on the differences.\n template \n class BEMProblem\n {\n public:\n BEMProblem(const unsigned int fe_degree = 1,\n const unsigned int mapping_degree = 1);\n\n void run();\n\n private:\n\n void read_parameters (const std::string &filename);\n\n void read_domain();\n\n void refine_and_resize();\n\n // The only really different function that we find here is the assembly\n // routine. We wrote this function in the most possible general way, in\n // order to allow for easy generalization to higher order methods and to\n // different fundamental solutions (e.g., Stokes or Maxwell).\n //\n // The most noticeable difference is the fact that the final matrix is\n // full, and that we have a nested loop inside the usual loop on cells\n // that visits all support points of the degrees of freedom. Moreover,\n // when the support point lies inside the cell which we are visiting, then\n // the integral we perform becomes singular.\n //\n // The practical consequence is that we have two sets of quadrature\n // formulas, finite element values and temporary storage, one for standard\n // integration and one for the singular integration, which are used where\n // necessary.\n void assemble_system();\n\n // There are two options for the solution of this problem. The first is to\n // use a direct solver, and the second is to use an iterative solver. We\n // opt for the second option.\n //\n // The matrix that we assemble is not symmetric, and we opt to use the\n // GMRES method; however the construction of an efficient preconditioner\n // for boundary element methods is not a trivial issue. Here we use a non\n // preconditioned GMRES solver. The options for the iterative solver, such\n // as the tolerance, the maximum number of iterations, are selected\n // through the parameter file.\n void solve_system();\n\n // Once we obtained the solution, we compute the $L^2$ error of the\n // computed potential as well as the $L^\\infty$ error of the approximation\n // of the solid angle. The mesh we are using is an approximation of a\n // smooth curve, therefore the computed diagonal matrix of fraction of\n // angles or solid angles $\\alpha(\\mathbf{x})$ should be constantly equal\n // to $\\frac 12$. In this routine we output the error on the potential and\n // the error in the approximation of the computed angle. Notice that the\n // latter error is actually not the error in the computation of the angle,\n // but a measure of how well we are approximating the sphere and the\n // circle.\n //\n // Experimenting a little with the computation of the angles gives very\n // accurate results for simpler geometries. To verify this you can comment\n // out, in the read_domain() method, the tria.set_boundary(1, boundary)\n // line, and check the alpha that is generated by the program. By removing\n // this call, whenever the mesh is refined new nodes will be placed along\n // the straight lines that made up the coarse mesh, rather than be pulled\n // onto the surface that we really want to approximate. In the three\n // dimensional case, the coarse grid of the sphere is obtained starting\n // from a cube, and the obtained values of alphas are exactly $\\frac 12$\n // on the nodes of the faces, $\\frac 34$ on the nodes of the edges and\n // $\\frac 78$ on the 8 nodes of the vertices.\n void compute_errors(const unsigned int cycle);\n\n // Once we obtained a solution on the codimension one domain, we want to\n // interpolate it to the rest of the space. This is done by performing\n // again the convolution of the solution with the kernel in the\n // compute_exterior_solution() function.\n //\n // We would like to plot the velocity variable which is the gradient of\n // the potential solution. The potential solution is only known on the\n // boundary, but we use the convolution with the fundamental solution to\n // interpolate it on a standard dim dimensional continuous finite element\n // space. The plot of the gradient of the extrapolated solution will give\n // us the velocity we want.\n //\n // In addition to the solution on the exterior domain, we also output the\n // solution on the domain's boundary in the output_results() function, of\n // course.\n void compute_exterior_solution();\n\n void output_results(const unsigned int cycle);\n\n // To allow for dimension independent programming, we specialize this\n // single function to extract the singular quadrature formula needed to\n // integrate the singular kernels in the interior of the cells.\n const Quadrature & get_singular_quadrature(\n const typename DoFHandler::active_cell_iterator &cell,\n const unsigned int index) const;\n\n\n // The usual deal.II classes can be used for boundary element methods by\n // specifying the \"codimension\" of the problem. This is done by setting\n // the optional second template arguments to Triangulation, FiniteElement\n // and DoFHandler to the dimension of the embedding space. In our case we\n // generate either 1 or 2 dimensional meshes embedded in 2 or 3\n // dimensional spaces.\n //\n // The optional argument by default is equal to the first argument, and\n // produces the usual finite element classes that we saw in all previous\n // examples.\n //\n // The class is constructed in a way to allow for arbitrary order of\n // approximation of both the domain (through high order mapping) and the\n // finite element space. The order of the finite element space and of the\n // mapping can be selected in the constructor of the class.\n\n Triangulation tria;\n FE_Q fe;\n DoFHandler dh;\n MappingQ mapping;\n\n // In BEM methods, the matrix that is generated is dense. Depending on the\n // size of the problem, the final system might be solved by direct LU\n // decomposition, or by iterative methods. In this example we use an\n // unpreconditioned GMRES method. Building a preconditioner for BEM method\n // is non trivial, and we don't treat this subject here.\n\n FullMatrix system_matrix;\n Vector system_rhs;\n\n // The next two variables will denote the solution $\\phi$ as well as a\n // vector that will hold the values of $\\alpha(\\mathbf x)$ (the fraction\n // of $\\Omega$ visible from a point $\\mathbf x$) at the support points of\n // our shape functions.\n\n Vector phi;\n Vector alpha;\n\n // The convergence table is used to output errors in the exact solution\n // and in the computed alphas.\n\n ConvergenceTable convergence_table;\n\n // The following variables are the ones that we fill through a parameter\n // file. The new objects that we use in this example are the\n // Functions::ParsedFunction object and the QuadratureSelector object.\n //\n // The Functions::ParsedFunction class allows us to easily and quickly\n // define new function objects via parameter files, with custom\n // definitions which can be very complex (see the documentation of that\n // class for all the available options).\n //\n // We will allocate the quadrature object using the QuadratureSelector\n // class that allows us to generate quadrature formulas based on an\n // identifying string and on the possible degree of the formula itself. We\n // used this to allow custom selection of the quadrature formulas for the\n // standard integration, and to define the order of the singular\n // quadrature rule.\n //\n // We also define a couple of parameters which are used in case we wanted\n // to extend the solution to the entire domain.\n\n Functions::ParsedFunction wind;\n Functions::ParsedFunction exact_solution;\n\n unsigned int singular_quadrature_order;\n std_cxx1x::shared_ptr > quadrature;\n\n SolverControl solver_control;\n\n unsigned int n_cycles;\n unsigned int external_refinement;\n\n bool run_in_this_dimension;\n bool extend_solution;\n };\n\n\n // @sect4{BEMProblem::BEMProblem and BEMProblem::read_parameters}\n\n // The constructor initializes the variuous object in much the same way as\n // done in the finite element programs such as step-4 or step-6. The only\n // new ingredient here is the ParsedFunction object, which needs, at\n // construction time, the specification of the number of components.\n //\n // For the exact solution the number of vector components is one, and no\n // action is required since one is the default value for a ParsedFunction\n // object. The wind, however, requires dim components to be\n // specified. Notice that when declaring entries in a parameter file for the\n // expression of the Functions::ParsedFunction, we need to specify the\n // number of components explicitly, since the function\n // Functions::ParsedFunction::declare_parameters is static, and has no\n // knowledge of the number of components.\n template \n BEMProblem::BEMProblem(const unsigned int fe_degree,\n const unsigned int mapping_degree)\n :\n fe(fe_degree),\n dh(tria),\n mapping(mapping_degree, true),\n wind(dim)\n {}\n\n\n template \n void BEMProblem::read_parameters (const std::string &filename)\n {\n deallog << std::endl << \"Parsing parameter file \" << filename << std::endl\n << \"for a \" << dim << \" dimensional simulation. \" << std::endl;\n\n ParameterHandler prm;\n\n prm.declare_entry(\"Number of cycles\", \"4\",\n Patterns::Integer());\n prm.declare_entry(\"External refinement\", \"5\",\n Patterns::Integer());\n prm.declare_entry(\"Extend solution on the -2,2 box\", \"true\",\n Patterns::Bool());\n prm.declare_entry(\"Run 2d simulation\", \"true\",\n Patterns::Bool());\n prm.declare_entry(\"Run 3d simulation\", \"true\",\n Patterns::Bool());\n\n prm.enter_subsection(\"Quadrature rules\");\n {\n prm.declare_entry(\"Quadrature type\", \"gauss\",\n Patterns::Selection(QuadratureSelector<(dim-1)>::get_quadrature_names()));\n prm.declare_entry(\"Quadrature order\", \"4\", Patterns::Integer());\n prm.declare_entry(\"Singular quadrature order\", \"5\", Patterns::Integer());\n }\n prm.leave_subsection();\n\n // For both two and three dimensions, we set the default input data to be\n // such that the solution is $x+y$ or $x+y+z$. The actually computed\n // solution will have value zero at infinity. In this case, this coincide\n // with the exact solution, and no additional corrections are needed, but\n // you should be aware of the fact that we arbitrarily set $\\phi_\\infty$,\n // and the exact solution we pass to the program needs to have the same\n // value at infinity for the error to be computed correctly.\n //\n // The use of the Functions::ParsedFunction object is pretty straight\n // forward. The Functions::ParsedFunction::declare_parameters function\n // takes an additional integer argument that specifies the number of\n // components of the given function. Its default value is one. When the\n // corresponding Functions::ParsedFunction::parse_parameters method is\n // called, the calling object has to have the same number of components\n // defined here, otherwise an exception is thrown.\n //\n // When declaring entries, we declare both 2 and three dimensional\n // functions. However only the dim-dimensional one is ultimately\n // parsed. This allows us to have only one parameter file for both 2 and 3\n // dimensional problems.\n //\n // Notice that from a mathematical point of view, the wind function on the\n // boundary should satisfy the condition $\\int_{\\partial\\Omega}\n // \\mathbf{v}\\cdot \\mathbf{n} d \\Gamma = 0$, for the problem to have a\n // solution. If this condition is not satisfied, then no solution can be\n // found, and the solver will not converge.\n prm.enter_subsection(\"Wind function 2d\");\n {\n Functions::ParsedFunction<2>::declare_parameters(prm, 2);\n prm.set(\"Function expression\", \"1; 1\");\n }\n prm.leave_subsection();\n\n prm.enter_subsection(\"Wind function 3d\");\n {\n Functions::ParsedFunction<3>::declare_parameters(prm, 3);\n prm.set(\"Function expression\", \"1; 1; 1\");\n }\n prm.leave_subsection();\n\n prm.enter_subsection(\"Exact solution 2d\");\n {\n Functions::ParsedFunction<2>::declare_parameters(prm);\n prm.set(\"Function expression\", \"x+y\");\n }\n prm.leave_subsection();\n\n prm.enter_subsection(\"Exact solution 3d\");\n {\n Functions::ParsedFunction<3>::declare_parameters(prm);\n prm.set(\"Function expression\", \"x+y+z\");\n }\n prm.leave_subsection();\n\n\n // In the solver section, we set all SolverControl parameters. The object\n // will then be fed to the GMRES solver in the solve_system() function.\n prm.enter_subsection(\"Solver\");\n SolverControl::declare_parameters(prm);\n prm.leave_subsection();\n\n // After declaring all these parameters to the ParameterHandler object,\n // let's read an input file that will give the parameters their values. We\n // then proceed to extract these values from the ParameterHandler object:\n prm.read_input(filename);\n\n n_cycles = prm.get_integer(\"Number of cycles\");\n external_refinement = prm.get_integer(\"External refinement\");\n extend_solution = prm.get_bool(\"Extend solution on the -2,2 box\");\n\n prm.enter_subsection(\"Quadrature rules\");\n {\n quadrature =\n std_cxx1x::shared_ptr >\n (new QuadratureSelector (prm.get(\"Quadrature type\"),\n prm.get_integer(\"Quadrature order\")));\n singular_quadrature_order = prm.get_integer(\"Singular quadrature order\");\n }\n prm.leave_subsection();\n\n prm.enter_subsection(std::string(\"Wind function \")+\n Utilities::int_to_string(dim)+std::string(\"d\"));\n {\n wind.parse_parameters(prm);\n }\n prm.leave_subsection();\n\n prm.enter_subsection(std::string(\"Exact solution \")+\n Utilities::int_to_string(dim)+std::string(\"d\"));\n {\n exact_solution.parse_parameters(prm);\n }\n prm.leave_subsection();\n\n prm.enter_subsection(\"Solver\");\n solver_control.parse_parameters(prm);\n prm.leave_subsection();\n\n\n // Finally, here's another example of how to use parameter files in\n // dimension independent programming. If we wanted to switch off one of\n // the two simulations, we could do this by setting the corresponding \"Run\n // 2d simulation\" or \"Run 3d simulation\" flag to false:\n run_in_this_dimension = prm.get_bool(\"Run \" +\n Utilities::int_to_string(dim) +\n \"d simulation\");\n }\n\n\n // @sect4{BEMProblem::read_domain}\n\n // A boundary element method triangulation is basically the same as a\n // (dim-1) dimensional triangulation, with the difference that the vertices\n // belong to a (dim) dimensional space.\n //\n // Some of the mesh formats supported in deal.II use by default three\n // dimensional points to describe meshes. These are the formats which are\n // compatible with the boundary element method capabilities of deal.II. In\n // particular we can use either UCD or GMSH formats. In both cases, we have\n // to be particularly careful with the orientation of the mesh, because,\n // unlike in the standard finite element case, no reordering or\n // compatibility check is performed here. All meshes are considered as\n // oriented, because they are embedded in a higher dimensional space. (See\n // the documentation of the GridIn and of the Triangulation for further\n // details on orientation of cells in a triangulation.) In our case, the\n // normals to the mesh are external to both the circle in 2d or the sphere\n // in 3d.\n //\n // The other detail that is required for appropriate refinement of the\n // boundary element mesh, is an accurate description of the manifold that\n // the mesh is approximating. We already saw this several times for the\n // boundary of standard finite element meshes (for example in step-5 and\n // step-6), and here the principle and usage is the same, except that the\n // HyperBallBoundary class takes an additional template parameter that\n // specifies the embedding space dimension. The function object still has to\n // be static to live at least as long as the triangulation object to which\n // it is attached.\n\n template \n void BEMProblem::read_domain()\n {\n static const Point center = Point();\n static const HyperBallBoundary boundary(center,1.);\n\n std::ifstream in;\n switch (dim)\n {\n case 2:\n in.open (\"coarse_circle.inp\");\n break;\n\n case 3:\n in.open (\"coarse_sphere.inp\");\n break;\n\n default:\n Assert (false, ExcNotImplemented());\n }\n\n GridIn gi;\n gi.attach_triangulation (tria);\n gi.read_ucd (in);\n\n tria.set_boundary(1, boundary);\n }\n\n\n // @sect4{BEMProblem::refine_and_resize}\n\n // This function globally refines the mesh, distributes degrees of freedom,\n // and resizes matrices and vectors.\n\n template \n void BEMProblem::refine_and_resize()\n {\n tria.refine_global(1);\n\n dh.distribute_dofs(fe);\n\n const unsigned int n_dofs = dh.n_dofs();\n\n system_matrix.reinit(n_dofs, n_dofs);\n\n system_rhs.reinit(n_dofs);\n phi.reinit(n_dofs);\n alpha.reinit(n_dofs);\n }\n\n\n // @sect4{BEMProblem::assemble_system}\n\n // The following is the main function of this program, assembling the matrix\n // that corresponds to the boundary integral equation.\n template \n void BEMProblem::assemble_system()\n {\n\n // First we initialize an FEValues object with the quadrature formula for\n // the integration of the kernel in non singular cells. This quadrature is\n // selected with the parameter file, and needs to be quite precise, since\n // the functions we are integrating are not polynomial functions.\n FEValues fe_v(mapping, fe, *quadrature,\n update_values |\n update_cell_normal_vectors |\n update_quadrature_points |\n update_JxW_values);\n\n const unsigned int n_q_points = fe_v.n_quadrature_points;\n\n std::vector local_dof_indices(fe.dofs_per_cell);\n\n std::vector > cell_wind(n_q_points, Vector(dim) );\n double normal_wind;\n\n // Unlike in finite element methods, if we use a collocation boundary\n // element method, then in each assembly loop we only assemble the\n // information that refers to the coupling between one degree of freedom\n // (the degree associated with support point $i$) and the current\n // cell. This is done using a vector of fe.dofs_per_cell elements, which\n // will then be distributed to the matrix in the global row $i$. The\n // following object will hold this information:\n Vector local_matrix_row_i(fe.dofs_per_cell);\n\n // The index $i$ runs on the collocation points, which are the support\n // points of the $i$th basis function, while $j$ runs on inner integration\n // points.\n\n // We construct a vector of support points which will be used in the local\n // integrations:\n std::vector > support_points(dh.n_dofs());\n DoFTools::map_dofs_to_support_points( mapping, dh, support_points);\n\n\n // After doing so, we can start the integration loop over all cells, where\n // we first initialize the FEValues object and get the values of\n // $\\mathbf{\\tilde v}$ at the quadrature points (this vector field should\n // be constant, but it doesn't hurt to be more general):\n typename DoFHandler::active_cell_iterator\n cell = dh.begin_active(),\n endc = dh.end();\n\n for (cell = dh.begin_active(); cell != endc; ++cell)\n {\n fe_v.reinit(cell);\n cell->get_dof_indices(local_dof_indices);\n\n const std::vector > &q_points = fe_v.get_quadrature_points();\n const std::vector > &normals = fe_v.get_normal_vectors();\n wind.vector_value_list(q_points, cell_wind);\n\n // We then form the integral over the current cell for all degrees of\n // freedom (note that this includes degrees of freedom not located on\n // the current cell, a deviation from the usual finite element\n // integrals). The integral that we need to perform is singular if one\n // of the local degrees of freedom is the same as the support point\n // $i$. A the beginning of the loop we therefore check wether this is\n // the case, and we store which one is the singular index:\n for (unsigned int i=0; i R = q_points[q] - support_points[i];\n\n system_rhs(i) += ( LaplaceKernel::single_layer(R) *\n normal_wind *\n fe_v.JxW(q) );\n\n for (unsigned int j=0; j & singular_quadrature =\n get_singular_quadrature(cell, singular_index);\n\n FEValues fe_v_singular (mapping, fe, singular_quadrature,\n update_jacobians |\n update_values |\n update_cell_normal_vectors |\n update_quadrature_points );\n\n fe_v_singular.reinit(cell);\n\n std::vector > singular_cell_wind( singular_quadrature.size(),\n Vector(dim) );\n\n const std::vector > &singular_normals = fe_v_singular.get_normal_vectors();\n const std::vector > &singular_q_points = fe_v_singular.get_quadrature_points();\n\n wind.vector_value_list(singular_q_points, singular_cell_wind);\n\n for (unsigned int q=0; q R = singular_q_points[q] - support_points[i];\n double normal_wind = 0;\n for (unsigned int d=0; d ones(dh.n_dofs());\n ones.add(-1.);\n\n system_matrix.vmult(alpha, ones);\n alpha.add(1);\n for (unsigned int i = 0; i\n void BEMProblem::solve_system()\n {\n SolverGMRES > solver (solver_control);\n solver.solve (system_matrix, phi, system_rhs, PreconditionIdentity());\n }\n\n\n // @sect4{BEMProblem::compute_errors}\n\n // The computation of the errors is exactly the same in all other example\n // programs, and we won't comment too much. Notice how the same methods that\n // are used in the finite element methods can be used here.\n template \n void BEMProblem::compute_errors(const unsigned int cycle)\n {\n Vector difference_per_cell (tria.n_active_cells());\n VectorTools::integrate_difference (mapping, dh, phi,\n exact_solution,\n difference_per_cell,\n QGauss<(dim-1)>(2*fe.degree+1),\n VectorTools::L2_norm);\n const double L2_error = difference_per_cell.l2_norm();\n\n\n // The error in the alpha vector can be computed directly using the\n // Vector::linfty_norm() function, since on each node, the value should be\n // $\\frac 12$. All errors are then output and appended to our\n // ConvergenceTable object for later computation of convergence rates:\n Vector difference_per_node(alpha);\n difference_per_node.add(-.5);\n\n const double alpha_error = difference_per_node.linfty_norm();\n const unsigned int n_active_cells=tria.n_active_cells();\n const unsigned int n_dofs=dh.n_dofs();\n\n deallog << \"Cycle \" << cycle << ':'\n << std::endl\n << \" Number of active cells: \"\n << n_active_cells\n << std::endl\n << \" Number of degrees of freedom: \"\n << n_dofs\n << std::endl;\n\n convergence_table.add_value(\"cycle\", cycle);\n convergence_table.add_value(\"cells\", n_active_cells);\n convergence_table.add_value(\"dofs\", n_dofs);\n convergence_table.add_value(\"L2(phi)\", L2_error);\n convergence_table.add_value(\"Linfty(alpha)\", alpha_error);\n }\n\n\n // Singular integration requires a careful selection of the quadrature\n // rules. In particular the deal.II library provides quadrature rules which\n // are taylored for logarithmic singularities (QGaussLog, QGaussLogR), as\n // well as for 1/R singularities (QGaussOneOverR).\n //\n // Singular integration is typically obtained by constructing weighted\n // quadrature formulas with singular weights, so that it is possible to\n // write\n //\n // \\f[ \\int_K f(x) s(x) dx = \\sum_{i=1}^N w_i f(q_i) \\f]\n //\n // where $s(x)$ is a given singularity, and the weights and quadrature\n // points $w_i,q_i$ are carefully selected to make the formula above an\n // equality for a certain class of functions $f(x)$.\n //\n // In all the finite element examples we have seen so far, the weight of the\n // quadrature itself (namely, the function $s(x)$), was always constantly\n // equal to 1. For singular integration, we have two choices: we can use\n // the definition above, factoring out the singularity from the integrand\n // (i.e., integrating $f(x)$ with the special quadrature rule), or we can\n // ask the quadrature rule to \"normalize\" the weights $w_i$ with $s(q_i)$:\n //\n // \\f[ \\int_K f(x) s(x) dx = \\int_K g(x) dx = \\sum_{i=1}^N\n // \\frac{w_i}{s(q_i)} g(q_i) \\f]\n //\n // We use this second option, through the @p factor_out_singularity\n // parameter of both QGaussLogR and QGaussOneOverR.\n //\n // These integrals are somewhat delicate, especially in two dimensions, due\n // to the transformation from the real to the reference cell, where the\n // variable of integration is scaled with the determinant of the\n // transformation.\n //\n // In two dimensions this process does not result only in a factor appearing\n // as a constant factor on the entire integral, but also on an additional\n // integral altogether that needs to be evaluated:\n //\n // \\f[ \\int_0^1 f(x)\\ln(x/\\alpha) dx = \\int_0^1 f(x)\\ln(x) dx - \\int_0^1\n // f(x) \\ln(\\alpha) dx. \\f]\n //\n // This process is taken care of by the constructor of the QGaussLogR class,\n // which adds additional quadrature points and weights to take into\n // consideration also the second part of the integral.\n //\n // A similar reasoning should be done in the three dimensional case, since\n // the singular quadrature is taylored on the inverse of the radius $r$ in\n // the reference cell, while our singular function lives in real space,\n // however in the three dimensional case everything is simpler because the\n // singularity scales linearly with the determinant of the\n // transformation. This allows us to build the singular two dimensional\n // quadrature rules only once and, reuse them over all cells.\n //\n // In the one dimensional singular integration this is not possible, since\n // we need to know the scaling parameter for the quadrature, which is not\n // known a priori. Here, the quadrature rule itself depends also on the size\n // of the current cell. For this reason, it is necessary to create a new\n // quadrature for each singular integration.\n //\n // The different quadrature rules are built inside the\n // get_singular_quadrature, which is specialized for dim=2 and dim=3, and\n // they are retrieved inside the assemble_system function. The index given\n // as an argument is the index of the unit support point where the\n // singularity is located.\n\n template<>\n const Quadrature<2> &BEMProblem<3>::get_singular_quadrature(\n const DoFHandler<2,3>::active_cell_iterator &,\n const unsigned int index) const\n {\n Assert(index < fe.dofs_per_cell,\n ExcIndexRange(0, fe.dofs_per_cell, index));\n\n static std::vector > quadratures;\n if (quadratures.size() == 0)\n for (unsigned int i=0; i(singular_quadrature_order,\n fe.get_unit_support_points()[i],\n true));\n return quadratures[index];\n }\n\n\n template<>\n const Quadrature<1> &BEMProblem<2>::get_singular_quadrature(\n const DoFHandler<1,2>::active_cell_iterator &cell,\n const unsigned int index) const\n {\n Assert(index < fe.dofs_per_cell,\n ExcIndexRange(0, fe.dofs_per_cell, index));\n\n static Quadrature<1> *q_pointer = NULL;\n if (q_pointer) delete q_pointer;\n\n q_pointer = new QGaussLogR<1>(singular_quadrature_order,\n fe.get_unit_support_points()[index],\n 1./cell->measure(), true);\n return (*q_pointer);\n }\n\n\n\n // @sect4{BEMProblem::compute_exterior_solution}\n\n // We'd like to also know something about the value of the potential $\\phi$\n // in the exterior domain: after all our motivation to consider the boundary\n // integral problem was that we wanted to know the velocity in the exterior\n // domain!\n //\n // To this end, let us assume here that the boundary element domain is\n // contained in the box $[-2,2]^{\\text{dim}}$, and we extrapolate the actual\n // solution inside this box using the convolution with the fundamental\n // solution. The formula for this is given in the introduction.\n //\n // The reconstruction of the solution in the entire space is done on a\n // continuous finite element grid of dimension dim. These are the usual\n // ones, and we don't comment any further on them. At the end of the\n // function, we output this exterior solution in, again, much the usual way.\n template \n void BEMProblem::compute_exterior_solution()\n {\n Triangulation external_tria;\n GridGenerator::hyper_cube(external_tria, -2, 2);\n\n FE_Q external_fe(1);\n DoFHandler external_dh (external_tria);\n Vector external_phi;\n\n external_tria.refine_global(external_refinement);\n external_dh.distribute_dofs(external_fe);\n external_phi.reinit(external_dh.n_dofs());\n\n typename DoFHandler::active_cell_iterator\n cell = dh.begin_active(),\n endc = dh.end();\n\n\n FEValues fe_v(mapping, fe, *quadrature,\n update_values |\n update_cell_normal_vectors |\n update_quadrature_points |\n update_JxW_values);\n\n const unsigned int n_q_points = fe_v.n_quadrature_points;\n\n std::vector dofs(fe.dofs_per_cell);\n\n std::vector local_phi(n_q_points);\n std::vector normal_wind(n_q_points);\n std::vector > local_wind(n_q_points, Vector(dim) );\n\n std::vector > external_support_points(external_dh.n_dofs());\n DoFTools::map_dofs_to_support_points(StaticMappingQ1::mapping,\n external_dh, external_support_points);\n\n for (cell = dh.begin_active(); cell != endc; ++cell)\n {\n fe_v.reinit(cell);\n\n const std::vector > &q_points = fe_v.get_quadrature_points();\n const std::vector > &normals = fe_v.get_normal_vectors();\n\n cell->get_dof_indices(dofs);\n fe_v.get_function_values(phi, local_phi);\n\n wind.vector_value_list(q_points, local_wind);\n\n for (unsigned int q=0; q R = q_points[q] - external_support_points[i];\n\n external_phi(i) += ( ( LaplaceKernel::single_layer(R) *\n normal_wind[q]\n +\n (LaplaceKernel::double_layer(R) *\n normals[q] ) *\n local_phi[q] ) *\n fe_v.JxW(q) );\n }\n }\n\n DataOut data_out;\n\n data_out.attach_dof_handler(external_dh);\n data_out.add_data_vector(external_phi, \"external_phi\");\n data_out.build_patches();\n\n const std::string\n filename = Utilities::int_to_string(dim) + \"d_external.vtk\";\n std::ofstream file(filename.c_str());\n\n data_out.write_vtk(file);\n }\n\n\n // @sect4{BEMProblem::output_results}\n\n // Outputting the results of our computations is a rather mechanical\n // tasks. All the components of this function have been discussed before.\n template \n void BEMProblem::output_results(const unsigned int cycle)\n {\n DataOut > dataout;\n\n dataout.attach_dof_handler(dh);\n dataout.add_data_vector(phi, \"phi\");\n dataout.add_data_vector(alpha, \"alpha\");\n dataout.build_patches(mapping,\n mapping.get_degree(),\n DataOut >::curved_inner_cells);\n\n std::string filename = ( Utilities::int_to_string(dim) +\n \"d_boundary_solution_\" +\n Utilities::int_to_string(cycle) +\n \".vtk\" );\n std::ofstream file(filename.c_str());\n\n dataout.write_vtk(file);\n\n if (cycle == n_cycles-1)\n {\n convergence_table.set_precision(\"L2(phi)\", 3);\n convergence_table.set_precision(\"Linfty(alpha)\", 3);\n\n convergence_table.set_scientific(\"L2(phi)\", true);\n convergence_table.set_scientific(\"Linfty(alpha)\", true);\n\n convergence_table\n .evaluate_convergence_rates(\"L2(phi)\", ConvergenceTable::reduction_rate_log2);\n convergence_table\n .evaluate_convergence_rates(\"Linfty(alpha)\", ConvergenceTable::reduction_rate_log2);\n deallog << std::endl;\n convergence_table.write_text(std::cout);\n }\n }\n\n\n // @sect4{BEMProblem::run}\n\n // This is the main function. It should be self explanatory in its\n // briefness:\n template \n void BEMProblem::run()\n {\n\n read_parameters(\"parameters.prm\");\n\n if (run_in_this_dimension == false)\n {\n deallog << \"Run in dimension \" << dim\n << \" explicitly disabled in parameter file. \"\n << std::endl;\n return;\n }\n\n read_domain();\n\n for (unsigned int cycle=0; cycle laplace_problem_2d(degree, mapping_degree);\n laplace_problem_2d.run();\n\n BEMProblem<3> laplace_problem_3d(degree, mapping_degree);\n laplace_problem_3d.run();\n }\n catch (std::exception &exc)\n {\n std::cerr << std::endl << std::endl\n << \"----------------------------------------------------\"\n << std::endl;\n std::cerr << \"Exception on processing: \" << std::endl\n << exc.what() << std::endl\n << \"Aborting!\" << std::endl\n << \"----------------------------------------------------\"\n << std::endl;\n\n return 1;\n }\n catch (...)\n {\n std::cerr << std::endl << std::endl\n << \"----------------------------------------------------\"\n << std::endl;\n std::cerr << \"Unknown exception!\" << std::endl\n << \"Aborting!\" << std::endl\n << \"----------------------------------------------------\"\n << std::endl;\n return 1;\n }\n\n return 0;\n}\n", "meta": {"hexsha": "424be3057e700628fe21a6488e93fd122263e099", "size": 45169, "ext": "cc", "lang": "C++", "max_stars_repo_path": "MHD/examples/step-34/step-34.cc", "max_stars_repo_name": "wathen/PhD", "max_stars_repo_head_hexsha": "35524f40028541a4d611d8c78574e4cf9ddc3278", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2020-10-25T13:30:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-10T21:27:30.000Z", "max_issues_repo_path": "MHD/examples/step-34/step-34.cc", "max_issues_repo_name": "wathen/PhD", "max_issues_repo_head_hexsha": "35524f40028541a4d611d8c78574e4cf9ddc3278", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "MHD/examples/step-34/step-34.cc", "max_forks_repo_name": "wathen/PhD", "max_forks_repo_head_hexsha": "35524f40028541a4d611d8c78574e4cf9ddc3278", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2019-10-28T16:12:13.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-13T13:59:44.000Z", "avg_line_length": 40.3655049151, "max_line_length": 106, "alphanum_fraction": 0.6337089597, "num_tokens": 10286, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.607663184043154, "lm_q2_score": 0.5736784074525096, "lm_q1q2_score": 0.3486032476893979}} {"text": "\n/******************************************************************************\n\n Triangulation algorithms for surface reconstruction problems.\n\n Copyright (c) 2013\n Alexander Rukletsov \n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions\n are met:\n 1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n 2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS \"AS IS\" AND\n ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\n OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n SUCH DAMAGE.\n\n*******************************************************************************/\n\n#ifndef TRIANGULATION_HPP_40CA4CA1_3752_4080_9BDE_D13393E21902\n#define TRIANGULATION_HPP_40CA4CA1_3752_4080_9BDE_D13393E21902\n\n#include \n#include \n#include \n\n#include \"bo/core/mesh.hpp\"\n#include \"bo/surfaces/detail/indexed_tstrip.hpp\"\n#include \"bo/surfaces/christiansen_tiling.hpp\"\n\nnamespace bo {\nnamespace surfaces {\n\n// This class contain various triangulation algorithms.\ntemplate \nclass Triangulation\n{\npublic:\n typedef bo::Mesh RealMesh;\n typedef ChristiansenTiling Christiansen;\n\npublic:\n // Performs modified Christiansen triangulation for two contours.\n template \n static RealMesh christiansen(const ContourDescrPtr& contour1,\n const ContourDescrPtr& contour2)\n {\n\n detail::IndexedTStrip tstrip = Christiansen(0, contour1->contour(), contour1->is_closed(),\n 1, contour2->contour(), contour2->is_closed())\n .run();\n\n // Calculate the total number of vertices to create mesh efficiently.\n std::size_t total_vertices = contour1->contour()->size() + contour2->contour()->size();\n\n // Populate the result mesh with vertices and store vertices shift for the\n // second contour (it should be 0 for the first).\n RealMesh mesh(total_vertices);\n std::vector lookup_table(2);\n lookup_table[0] = mesh.add_vertices(*(contour1->contour()));\n lookup_table[1] = mesh.add_vertices(*(contour2->contour()));\n\n // Populate the result mesh with faces. Transform old \n // keys into new keys using lookup table.\n BOOST_FOREACH (const detail::IndexedTStrip::Face& face, tstrip.get_faces())\n {\n std::size_t new_a = lookup_table[face.A().first] + face.A().second;\n std::size_t new_b = lookup_table[face.B().first] + face.B().second;\n std::size_t new_c = lookup_table[face.C().first] + face.C().second;\n mesh.add_face(typename RealMesh::Face(new_a, new_b, new_c));\n }\n\n return mesh;\n }\n\n // Performs modified Christiansen triangulation for a collection of contours.\n // Note that the collection must be sorted, because the algorithm connects adjacent\n // contours.\n template \n static RealMesh christiansen(const std::vector& contours)\n {\n std::size_t total_contours = contours.size();\n detail::IndexedTStrip::TStrips tstrips_;\n\n for (std::size_t idx = 1; idx < total_contours; ++idx)\n {\n ContourDescrPtr cur_contour = contours[idx];\n ContourDescrPtr prev_contour = contours[idx - 1];\n\n Christiansen triang(\n idx - 1, prev_contour->contour(), prev_contour->is_closed(),\n idx, cur_contour->contour(), cur_contour->is_closed());\n\n detail::IndexedTStrip tstrip = triang.run();\n tstrips_.push_back(tstrip);\n }\n\n // Union all tstrips into one mesh.\n detail::IndexedTStrip joined_tstrips = detail::IndexedTStrip::join(tstrips_);\n\n // Calculate the total number of vertices to create mesh efficiently.\n std::size_t total_vertices = 0;\n BOOST_FOREACH (const ContourDescrPtr& c, contours)\n { total_vertices += c->contour()->size(); }\n\n // Populate the result mesh with vertices and create lookup tables.\n RealMesh mesh(total_vertices);\n std::vector lookup_table(total_contours);\n for (std::size_t idx = 0; idx < total_contours; ++idx)\n {\n std::size_t current_offset = mesh.add_vertices(*(contours[idx]->contour()));\n lookup_table[idx] = current_offset;\n }\n\n // Populate the result mesh with faces. Transform old \n // keys into new keys using lookup table.\n BOOST_FOREACH (const detail::IndexedTStrip::Face& face, joined_tstrips.get_faces())\n {\n std::size_t new_a = lookup_table[face.A().first] + face.A().second;\n std::size_t new_b = lookup_table[face.B().first] + face.B().second;\n std::size_t new_c = lookup_table[face.C().first] + face.C().second;\n mesh.add_face(typename RealMesh::Face(new_a, new_b, new_c));\n }\n\n return mesh;\n }\n};\n\n} // namespace surfaces\n} // namespace bo\n\n#endif // TRIANGULATION_HPP_40CA4CA1_3752_4080_9BDE_D13393E21902\n", "meta": {"hexsha": "2f6d40ab30b043187adfc7cec90a95d07789f67c", "size": 6175, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "Bo/surfaces/triangulation.hpp", "max_stars_repo_name": "rukletsov/bo", "max_stars_repo_head_hexsha": "bfece9e8f910b0c8f522733854405bf0a801b0e8", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2016-09-14T03:30:30.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-16T10:53:32.000Z", "max_issues_repo_path": "Bo/surfaces/triangulation.hpp", "max_issues_repo_name": "rukletsov/bo", "max_issues_repo_head_hexsha": "bfece9e8f910b0c8f522733854405bf0a801b0e8", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Bo/surfaces/triangulation.hpp", "max_forks_repo_name": "rukletsov/bo", "max_forks_repo_head_hexsha": "bfece9e8f910b0c8f522733854405bf0a801b0e8", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.2945205479, "max_line_length": 98, "alphanum_fraction": 0.6655870445, "num_tokens": 1407, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6076631698328917, "lm_q2_score": 0.5736784074525098, "lm_q1q2_score": 0.3486032395372773}} {"text": "//\n// $Id: ParameterEstimator.cpp 2051 2010-06-15 18:39:13Z chambm $\n//\n//\n// Original author: Darren Kessner \n//\n// Copyright 2006 Louis Warschaw Prostate Cancer Center\n// Cedars Sinai Medical Center, Los Angeles, California 90048\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\"); \n// you may not use this file except in compliance with the License. \n// You may obtain a copy of the License at \n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software \n// distributed under the License is distributed on an \"AS IS\" BASIS, \n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. \n// See the License for the specific language governing permissions and \n// limitations under the License.\n//\n\n\n#include \"ParameterEstimator.hpp\"\n//#include \"DerivativeTest.hpp\" // for testing numerical derivatives only\n\n#include \"pwiz/utility/misc/Std.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \nnamespace ublas = boost::numeric::ublas;\n\n\nnamespace pwiz {\nnamespace frequency {\n\n\nclass ParameterEstimatorImpl : public ParameterEstimator\n{\n public:\n\n ParameterEstimatorImpl(const Function& function,\n const Data& data,\n const Parameters& initialEstimate);\n\n virtual const Parameters& estimate() const {return p_;}\n virtual void estimate(const Parameters& p) {p_ = p;}\n virtual double error() const {return e_(p_);}\n virtual double iterate(ostream* log);\n\n private:\n\n const Function& f_;\n const Data& data_;\n Parameters p_;\n Function::ErrorFunction e_;\n\n Parameters solve(const ublas::matrix& A , const ublas::vector& y) const;\n};\n\n\nauto_ptr ParameterEstimator::create(const Function& function,\n const Data& data,\n const Parameters& initialEstimate)\n{\n return auto_ptr(new ParameterEstimatorImpl(function, data, initialEstimate));\n}\n\n\nParameterEstimatorImpl::ParameterEstimatorImpl(const Function& function,\n const Data& data,\n const Parameters& initialEstimate)\n: f_(function),\n data_(data),\n p_(initialEstimate),\n e_(f_, data_)\n{\n if (function.parameterCount() != initialEstimate.size())\n throw logic_error(\"[ParameterEstimator::ParameterEstimatorImpl()] Wrong number of parameters.\");\n}\n\n\ndouble ParameterEstimatorImpl::iterate(ostream* log)\n{\n // DerivativeTest::testDerivatives< complex >(e_, p_); // testing only\n\n double error_old = error();\n\n ublas::vector d = e_.dp(p_);\n ublas::matrix d2 = e_.dp2(p_);\n\n // calculate new estimate:\n // correction == inverse(d2) * d\n // p_new = p_old - correction\n\n Parameters correction = solve(d2, d);\n\n // compare error change to prediction from parabolic approximation\n ublas::vector dp = -correction;\n double error_change_predicted = inner_prod(d, dp) + .5*inner_prod(dp, prod(d2,dp));\n double error_change_actual = e_(p_-correction) - error_old;\n\n\n if (log) *log << \"d: \" << d << endl;\n if (log) *log << \"d2: \" << d2 << endl;\n if (log) *log << \"correction: \" << correction << endl;\n if (log) *log << \"error_change_predicted: \" << error_change_predicted << endl;\n if (log) *log << \"error_change_actual: \" << error_change_actual << endl;\n\n\n // if we can decrease error -- go for it!\n if (error_change_actual < 0)\n {\n p_ -= correction;\n return error_change_actual;\n }\n\n // error is going to increase if we make the full correction;\n // backtrack along correction gradient to find decreasing error\n\n Parameters correction_backtrack = correction;\n int zeroCount = 0;\n\n for (int i=0; i<10; i++)\n {\n correction_backtrack /= 2;\n double error_change_backtrack = e_(p_ - correction_backtrack) - error_old;\n if (log) *log << \"error_change_backtrack: \" << error_change_backtrack << endl;\n if (error_change_backtrack < 0)\n {\n // found negative error change -- go for it!\n p_ -= correction_backtrack;\n return error_change_backtrack;\n }\n else if (error_change_backtrack == 0)\n {\n zeroCount++;\n if (zeroCount >= 3) // stuck on zero -- we're outta here\n break;\n }\n }\n\n // don't correct\n if (log) *log << \"No correction.\\n\";\n return 0;\n}\n\n\nParameterEstimatorImpl::Parameters ParameterEstimatorImpl::solve(const ublas::matrix& A , const ublas::vector& y) const\n{\n // solve Ax = y\n\n ublas::matrix A_factorized = A;\n\n ublas::permutation_matrix pm(e_.parameterCount());\n int singular = lu_factorize(A_factorized, pm);\n if (singular)\n throw runtime_error(\"[ParameterEstimatorImpl::solve()] A is singular.\");\n\n ublas::vector result(y);\n lu_substitute(A_factorized, pm, result);\n return result;\n}\n\n\n} // namespace frequency\n} // namespace pwiz\n\n", "meta": {"hexsha": "51e739593646b519f895c7e3a8e529e3d3d8c87b", "size": 5453, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "pwiz/analysis/frequency/ParameterEstimator.cpp", "max_stars_repo_name": "edyp-lab/pwiz-mzdb", "max_stars_repo_head_hexsha": "d13ce17f4061596c7e3daf9cf5671167b5996831", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2015-01-08T08:33:44.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-12T06:14:54.000Z", "max_issues_repo_path": "pwiz/analysis/frequency/ParameterEstimator.cpp", "max_issues_repo_name": "shze/pwizard-deb", "max_issues_repo_head_hexsha": "4822829196e915525029a808470f02d24b8b8043", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 61.0, "max_issues_repo_issues_event_min_datetime": "2015-05-27T11:20:11.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-20T15:06:21.000Z", "max_forks_repo_path": "pwiz/analysis/frequency/ParameterEstimator.cpp", "max_forks_repo_name": "shze/pwizard-deb", "max_forks_repo_head_hexsha": "4822829196e915525029a808470f02d24b8b8043", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2016-02-03T09:41:16.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-01T18:42:36.000Z", "avg_line_length": 31.7034883721, "max_line_length": 135, "alphanum_fraction": 0.6444159178, "num_tokens": 1284, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6076631556226292, "lm_q2_score": 0.5736784074525096, "lm_q1q2_score": 0.3486032313851564}} {"text": "#ifndef STAN_MATH_PRIM_SCAL_FUN_LOCSCALE_FREE_HPP\n#define STAN_MATH_PRIM_SCAL_FUN_LOCSCALE_FREE_HPP\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace stan {\nnamespace math {\n\n/**\n * Return the unconstrained scalar that transforms to the\n * specified location and scale constrained scalar given the specified\n * location and scale.\n *\n *

The transfrom in locscale_constrain(T, double, double),\n * is reversed by the reverse affine transformation,\n *\n *

\\f$f^{-1}(y) = \\frac{y - L}{S}\\f$\n *\n * where \\f$L\\f$ and \\f$S\\f$ are the location and scale.\n *\n *

If the location is zero and scale is one,\n * this function reduces to identity_free(y).\n *\n * @tparam T type of scalar\n * @tparam L type of location\n * @tparam S type of scale\n * @param y constrained value\n * @param[in] mu location of constrained output\n * @param[in] sigma scale of constrained output\n * @return the free scalar that transforms to the input scalar\n * given the location and scale\n * @throw std::domain_error if sigma <= 0\n * @throw std::domain_error if mu is not finite\n */\ntemplate \ninline typename boost::math::tools::promote_args::type locscale_free(\n const T& y, const L& mu, const S& sigma) {\n check_finite(\"locscale_free\", \"location\", mu);\n if (sigma == 1) {\n if (mu == 0)\n return identity_free(y);\n return y - mu;\n }\n check_positive_finite(\"locscale_free\", \"scale\", sigma);\n return (y - mu) / sigma;\n}\n\n} // namespace math\n} // namespace stan\n#endif\n", "meta": {"hexsha": "6ac928aa0fbf43eb62530b50e148c6241cffd9bb", "size": 1735, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "stan/math/prim/scal/fun/locscale_free.hpp", "max_stars_repo_name": "jrmie/math", "max_stars_repo_head_hexsha": "2850ec262181075a5843968e805dc9ad1654e069", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "stan/math/prim/scal/fun/locscale_free.hpp", "max_issues_repo_name": "jrmie/math", "max_issues_repo_head_hexsha": "2850ec262181075a5843968e805dc9ad1654e069", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "stan/math/prim/scal/fun/locscale_free.hpp", "max_forks_repo_name": "jrmie/math", "max_forks_repo_head_hexsha": "2850ec262181075a5843968e805dc9ad1654e069", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.9821428571, "max_line_length": 78, "alphanum_fraction": 0.7083573487, "num_tokens": 468, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6513548782017745, "lm_q2_score": 0.5350984286266115, "lm_q1q2_score": 0.34853897180404747}} {"text": "/**\n * cartesian_pose_control.cc\n *\n * Copyright 2019. All Rights Reserved.\n * Stanford IPRL\n *\n * Created: January 16, 2019\n * Authors: Mengyuan Yan\n */\n\n#include \"control_thread.h\"\n\n#include // std::all_of\n#include // std::array\n#include // std::abs, std::acos, std::cos, std::pow, std::sin, std::sqrt\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"shared_memory.h\"\n\nnamespace franka_driver {\n\n/**\n * Sets a default collision behavior, joint impedance, Cartesian impedance, and filter frequency.\n *\n * @param[in] robot Robot instance to set behavior on.\n */\nvoid setDefaultBehavior(franka::Robot& robot);\n\n/**\n * Generate a joint pose motion to a goal position. Adapted from:\n * Wisama Khalil and Etienne Dombre. 2002. Modeling, Identification and Control of Robots\n * (Kogan Page Science Paper edition).\n */\nclass MotionGenerator {\n public:\n\n /**\n * Creates a new MotionGenerator instance.\n */\n MotionGenerator();\n\n /**\n * reset MotionGenerator for a target q.\n *\n * @param[in] speed_factor General speed factor in range [0, 1].\n * @param[in] pose_goal Target end-effector pose.\n */\n void reset(double speed_factor, const std::array pose_goal);\n\n /**\n * Sends next pose command\n *\n * @param[in] robot_state Current state of the robot.\n * @param[in] period Duration of execution.\n *\n * @return end-effector pose for use inside a control loop.\n */\n franka::CartesianPose operator()(const franka::RobotState& robot_state, franka::Duration period);\n\n private:\n using Vector3d = Eigen::Matrix;\n using Vector2d = Eigen::Matrix;\n using Matrix4x4d = Eigen::Matrix;\n using Matrix3x3d = Eigen::Matrix;\n\n bool calculateDesiredValues(double t, Vector2d* delta_pose_d) const;\n void calculateSynchronizedValues();\n void preCalculateRotationMatrices();\n\n // tranlational and rotation angle residual threshold\n static constexpr std::array kDeltaMotionFinished = {1e-4, 0.01};\n Matrix4x4d pose_goal_;\n Matrix4x4d pose_start_;\n Vector3d unit_T_;\n Vector3d axis_R_;\n Vector2d delta_q_; // delta_trans_, delta_angle_\n\n Matrix3x3d precompute_pose_eye_;\n Matrix3x3d precompute_pose_dot_;\n Matrix3x3d precompute_pose_cross_;\n\n Vector2d dq_max_sync_;\n Vector2d t_1_sync_;\n Vector2d t_2_sync_;\n Vector2d t_f_sync_;\n Vector2d q_1_;\n\n double time_ = 0.0;\n\n const Vector2d default_dq_max_ = (Vector2d() << 0.1, 0.4).finished(); // 0.2m/s, 1.0rad/s\n const Vector2d default_ddq_max_start_ = (Vector2d() << 0.2, 0.5).finished();\n const Vector2d default_ddq_max_goal_ = (Vector2d() << 0.2, 0.5).finished();\n Vector2d dq_max_;\n Vector2d ddq_max_start_;\n Vector2d ddq_max_goal_;\n\n};\n\nvoid setDefaultBehavior(franka::Robot& robot) {\n robot.setCollisionBehavior(\n {{20.0, 20.0, 20.0, 20.0, 20.0, 20.0, 20.0}}, {{20.0, 20.0, 20.0, 20.0, 20.0, 20.0, 20.0}},\n {{10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0}}, {{10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0}},\n {{20.0, 20.0, 20.0, 20.0, 20.0, 20.0}}, {{20.0, 20.0, 20.0, 20.0, 20.0, 20.0}},\n {{10.0, 10.0, 10.0, 10.0, 10.0, 10.0}}, {{10.0, 10.0, 10.0, 10.0, 10.0, 10.0}});\n robot.setJointImpedance({{3000, 3000, 3000, 2500, 2500, 2000, 2000}});\n robot.setCartesianImpedance({{3000, 3000, 3000, 300, 300, 300}});\n}\n\n// This is for gcc 5.4, does not need this line with gcc6.4\n// Refer to https://stackoverflow.com/questions/8016780/undefined-reference-to-static-constexpr-char\nconstexpr std::array MotionGenerator::kDeltaMotionFinished;\n\nMotionGenerator::MotionGenerator() {\n dq_max_sync_.setZero();\n pose_start_.setZero();\n pose_goal_.setZero();\n unit_T_.setZero();\n axis_R_.setZero();\n delta_q_.setZero();\n t_1_sync_.setZero();\n t_2_sync_.setZero();\n t_f_sync_.setZero();\n q_1_.setZero();\n}\n\nvoid MotionGenerator::reset(double speed_factor, const std::array pose_goal)\n{\n dq_max_ = default_dq_max_ * speed_factor;\n ddq_max_start_ = default_ddq_max_start_ * speed_factor;\n ddq_max_goal_ = default_ddq_max_goal_ * speed_factor;\n dq_max_sync_.setZero();\n pose_start_.setZero();\n pose_goal_ = Matrix4x4d(pose_goal.data());\n unit_T_.setZero();\n axis_R_.setZero();\n delta_q_.setZero();\n t_1_sync_.setZero();\n t_2_sync_.setZero();\n t_f_sync_.setZero();\n q_1_.setZero();\n time_ = 0;\n}\n\nbool MotionGenerator::calculateDesiredValues(double t, Vector2d* delta_q_d) const {\n // Vector2d t_d = t_2_sync_ - t_1_sync_;\n Vector2d delta_t_2_sync = t_f_sync_ - t_2_sync_;\n std::array motion_finished{};\n\n for (size_t i = 0; i < 2; i++) {\n if (std::abs(delta_q_[i]) < kDeltaMotionFinished[i]) {\n (*delta_q_d)[i] = 0;\n motion_finished[i] = true;\n } else {\n if (t < t_1_sync_[i]) {\n (*delta_q_d)[i] = -1.0 / (t_1_sync_[i]*t_1_sync_[i]*t_1_sync_[i]) * dq_max_sync_[i] *\n (0.5 * t - t_1_sync_[i]) * (t*t*t);\n } else if (t >= t_1_sync_[i] && t < t_2_sync_[i]) {\n (*delta_q_d)[i] = q_1_[i] + (t - t_1_sync_[i]) * dq_max_sync_[i];\n } else if (t >= t_2_sync_[i] && t < t_f_sync_[i]) {\n double tt = t - t_2_sync_[i];\n (*delta_q_d)[i] =\n delta_q_[i] + 0.5 * (1.0 / (delta_t_2_sync[i]*delta_t_2_sync[i]*delta_t_2_sync[i]) *\n (tt - 2.0 * delta_t_2_sync[i]) * (tt*tt*tt) +\n (2.0 * tt - delta_t_2_sync[i])) * dq_max_sync_[i];\n } else {\n (*delta_q_d)[i] = delta_q_[i];\n motion_finished[i] = true;\n }\n }\n }\n return std::all_of(motion_finished.cbegin(), motion_finished.cend(),\n [](bool x) { return x; });\n}\n\nvoid MotionGenerator::calculateSynchronizedValues() {\n Vector2d dq_max_reach(dq_max_);\n Vector2d t_f = Vector2d::Zero();\n Vector2d delta_t_2 = Vector2d::Zero();\n Vector2d t_1 = Vector2d::Zero();\n Vector2d delta_t_2_sync = Vector2d::Zero();\n\n unit_T_ = pose_goal_.block<3,1>(0,3) - pose_start_.block<3,1>(0,3);\n delta_q_[0] = unit_T_.norm();\n if (delta_q_[0] > 0) unit_T_ = unit_T_ / delta_q_[0];\n\n Matrix3x3d delta_R_;\n delta_R_ = pose_goal_.block<3,3>(0,0) * pose_start_.block<3,3>(0,0).transpose();\n // matrix to axis-angle\n double cos_angle = (delta_R_.trace()-1)/2;\n delta_q_[1] = std::acos(cos_angle);\n if (cos_angle < 0) {\n // more stable way of calculating axis when angle close to pi.\n axis_R_(0) = std::sqrt((delta_R_(0,0)-cos_angle)/2);\n axis_R_(1) = std::sqrt((delta_R_(1,1)-cos_angle)/2);\n axis_R_(2) = std::sqrt((delta_R_(2,2)-cos_angle)/2);\n if (delta_R_(0,1)-delta_R_(1,0) > 0) axis_R_(2) = -axis_R_(2);\n if (delta_R_(2,0)-delta_R_(0,2) > 0) axis_R_(1) = -axis_R_(1);\n if (delta_R_(1,2)-delta_R_(2,1) > 0) axis_R_(0) = -axis_R_(0);\n axis_R_.normalize();\n } else {\n // more stable way of calculating axis when angle close to 0.\n axis_R_(0) = delta_R_(2,1) - delta_R_(1,2);\n axis_R_(1) = delta_R_(0,2) - delta_R_(2,0);\n axis_R_(2) = delta_R_(1,0) - delta_R_(0,1);\n if (axis_R_.norm() > 0) axis_R_.normalize();\n }\n\n for (size_t i = 0; i < 2; i++) {\n if (std::abs(delta_q_[i]) > kDeltaMotionFinished[i]) {\n if (std::abs(delta_q_[i]) < (3.0 / 4.0 * (std::pow(dq_max_[i], 2.0) / ddq_max_start_[i]) +\n 3.0 / 4.0 * (std::pow(dq_max_[i], 2.0) / ddq_max_goal_[i]))) {\n dq_max_reach[i] = std::sqrt(4.0 / 3.0 * delta_q_[i] *\n (ddq_max_start_[i] * ddq_max_goal_[i]) /\n (ddq_max_start_[i] + ddq_max_goal_[i]));\n }\n t_1[i] = 1.5 * dq_max_reach[i] / ddq_max_start_[i];\n delta_t_2[i] = 1.5 * dq_max_reach[i] / ddq_max_goal_[i];\n t_f[i] = t_1[i] / 2.0 + delta_t_2[i] / 2.0 + std::abs(delta_q_[i]) / dq_max_reach[i];\n }\n }\n double max_t_f = t_f.maxCoeff();\n for (size_t i = 0; i < 2; i++) {\n if (std::abs(delta_q_[i]) > kDeltaMotionFinished[i]) {\n double a = 1.5 / 2.0 * (ddq_max_goal_[i] + ddq_max_start_[i]);\n double b = -1.0 * max_t_f * ddq_max_goal_[i] * ddq_max_start_[i];\n double c = std::abs(delta_q_[i]) * ddq_max_goal_[i] * ddq_max_start_[i];\n double delta = b * b - 4.0 * a * c;\n if (delta < 0.0) {\n delta = 0.0;\n }\n dq_max_sync_[i] = (-1.0 * b - std::sqrt(delta)) / (2.0 * a);\n t_1_sync_[i] = 1.5 * dq_max_sync_[i] / ddq_max_start_[i];\n delta_t_2_sync[i] = 1.5 * dq_max_sync_[i] / ddq_max_goal_[i];\n t_f_sync_[i] =\n (t_1_sync_)[i] / 2.0 + delta_t_2_sync[i] / 2.0 + std::abs(delta_q_[i] / dq_max_sync_[i]);\n t_2_sync_[i] = t_f_sync_[i] - delta_t_2_sync[i];\n q_1_[i] = dq_max_sync_[i] * 0.5 * t_1_sync_[i];\n }\n }\n}\n\nvoid MotionGenerator::preCalculateRotationMatrices() {\n precompute_pose_eye_ = pose_start_.block<3,3>(0,0);\n precompute_pose_dot_ = axis_R_*axis_R_.transpose()*precompute_pose_eye_;\n precompute_pose_cross_ = Eigen::MatrixXd::Zero(3,3);\n precompute_pose_cross_(0,1) = -axis_R_(2);\n precompute_pose_cross_(1,0) = axis_R_(2);\n precompute_pose_cross_(0,2) = axis_R_(1);\n precompute_pose_cross_(2,0) = -axis_R_(1);\n precompute_pose_cross_(1,2) = -axis_R_(0);\n precompute_pose_cross_(2,1) = axis_R_(0);\n precompute_pose_cross_ = precompute_pose_cross_ * precompute_pose_eye_;\n}\n\nfranka::CartesianPose MotionGenerator::operator()(const franka::RobotState& robot_state,\n franka::Duration period) {\n time_ += period.toSec();\n\n if (time_ == 0.0) {\n pose_start_ = Matrix4x4d(robot_state.O_T_EE_c.data());\n calculateSynchronizedValues();\n preCalculateRotationMatrices();\n }\n\n Vector2d delta_q_d;\n bool motion_finished = calculateDesiredValues(time_, &delta_q_d);\n\n std::array command_pose;\n Eigen::Map command_pose_e(&command_pose[0]);\n command_pose_e = pose_start_;\n\n if (delta_q_d[0] > 0) {\n command_pose_e.block<3,1>(0,3) += delta_q_d[0] * unit_T_;\n }\n if (delta_q_d[1] > 0) {\n command_pose_e.block<3,3>(0,0) = std::cos(delta_q_d[1]) * precompute_pose_eye_ +\n (1 - std::cos(delta_q_d[1])) * precompute_pose_dot_ +\n std::sin(delta_q_d[1]) * precompute_pose_cross_;\n }\n// std::cout << command_pose_e << std::endl;\n// std::cout << command_pose_e.transpose()*command_pose_e << std::endl;\n franka::CartesianPose output(command_pose);\n output.motion_finished = motion_finished;\n return output;\n}\n\nstd::function\nCreateCartesianPoseController(const Args& args, const std::shared_ptr& globals,\n franka::Robot& robot, const franka::Model& model) {\n std::shared_ptr motion_generator = std::make_shared();\n \n franka::RobotState state = robot.readOnce();\n std::array pose_command = globals->pose_command;\n if (globals->control_mode == ControlMode::DELTA_CARTESIAN_POSE) {\n Eigen::Map start_pose_e(state.O_T_EE.data());\n Eigen::Map command_pose_e(pose_command.data());\n command_pose_e.topRightCorner<3,1>() += start_pose_e.topRightCorner<3,1>();\n command_pose_e.topLeftCorner<3,3>() = command_pose_e.topLeftCorner<3,3>() * start_pose_e.topLeftCorner<3,3>();\n }\n motion_generator->reset(1., pose_command);\n\n return [globals, motion_generator](const franka::RobotState& state, franka::Duration dt) -> franka::CartesianPose {\n static const auto t_start = std::chrono::steady_clock::now();\n if (!*globals->runloop) {\n throw std::runtime_error(\"TorqueController(): SIGINT.\");\n }\n\n // Set sensor values\n globals->q = state.q;\n globals->dq = state.dq;\n globals->tau = state.tau_J;\n globals->dtau = state.dtau_J;\n\n // Set time\n const auto ms_now = std::chrono::duration_cast>(std::chrono::steady_clock::now() - t_start);\n globals->time = globals->time + ms_now.count();\n\n // Get command torques\n if (globals->control_mode != ControlMode::CARTESIAN_POSE) {\n throw SwitchControllerException(\"cartesian_pose\");\n }\n\n return (*motion_generator)(state, dt);\n };\n}\n\n} // namespace franka_driver\n", "meta": {"hexsha": "e96b09f01041a1ed830395c0d3d0b8a84c0b22e6", "size": 12416, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/cartesian_pose_control.cc", "max_stars_repo_name": "stanford-iprl-lab/franka-panda-public", "max_stars_repo_head_hexsha": "13b8e7d7400001e1c96c78fef5ecf34c179529f9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-01-15T00:15:06.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-15T09:33:47.000Z", "max_issues_repo_path": "src/cartesian_pose_control.cc", "max_issues_repo_name": "stanford-iprl-lab/franka-panda-public", "max_issues_repo_head_hexsha": "13b8e7d7400001e1c96c78fef5ecf34c179529f9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/cartesian_pose_control.cc", "max_forks_repo_name": "stanford-iprl-lab/franka-panda-public", "max_forks_repo_head_hexsha": "13b8e7d7400001e1c96c78fef5ecf34c179529f9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-01-21T22:32:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-21T22:32:24.000Z", "avg_line_length": 37.1736526946, "max_line_length": 126, "alphanum_fraction": 0.6461823454, "num_tokens": 4134, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6513548646660543, "lm_q2_score": 0.5350984286266115, "lm_q1q2_score": 0.34853896456110484}} {"text": "// Functions for computing scores that assess the significance of TCR clusters\n// Z_CO and S_size in the terminology of the original manuscript\n//\n\n#ifndef INCLUDED_pubtcrs_cluster_scores_HH\n#define INCLUDED_pubtcrs_cluster_scores_HH\n\n#include \n\n#include \"misc.hh\"\n#include \"randutil.hh\"\n\n\n////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n//\n// both lists should sum to the same thing: the sum of the subject counts for all the tcrs in the cluster\n//\n//\nReal // return the best score\nscore_l1_versus_l2(\n\tReals const & l1, // should be sorted\n\tReals const & l2, // -- ditto --\n\tSize & min_switchpoint // for i <= min_switchpoint, score += l1[i] - l2[i];\n) // i > min_switchpoint, score += l2[i] - l2[i];\n{\n\tReal const epsilon( 1e-4 );\n\n\truntime_assert( l1.front() >= l1.back()-epsilon ); // silly check for sorted\n\truntime_assert( l2.front() >= l2.back()-epsilon ); // ditto\n\n\tSize const nsubjects( l2.size() );\n\n\truntime_assert( l1.size() == nsubjects );\n\n\tReals total_l1_minus_l2;\n\n\tReal total(0);\n\tfor ( Size i=0; i< nsubjects; ++i ) {\n\t\ttotal += l1[i] - l2[i];\n\t\ttotal_l1_minus_l2.push_back( total );\n\t}\n\n\truntime_assert( fabs( total_l1_minus_l2[ nsubjects-1 ] - 0.0 ) 0; --i ) {\n\t\ttotal += l2[i] - l1[i];\n\t\t// this is the score if min_switchpoint were i-1:\n\t\tscore = total_l1_minus_l2[ i-1 ] + total;\n\t\tif ( score >= best_score - epsilon ) { // choose smaller switchpoints with equal scores\n\t\t\tbest_score = score;\n\t\t\tmin_switchpoint = i-1;\n\t\t}\n\t}\n\n\treturn best_score;\n\n}\n\n////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\nReal // return diff_Zscore\nanalyze_cluster_occurrences(\n\tSizes const & tcrs,\n\tvector< bools > const & all_occs, // could be just intra-HLA occs\n\tSizes const & subject_indices, // for output, eg might be: ( hla_positive_subjects.find(hla)->second ) );\n\tReals const & subject_sampling_bias,\n\tSize const nrep,\n\tstring const tag, // empty for classic output\n\tSize & upper_tcr_count,\n\tSize & lower_tcr_count,\n\tostream & out\n)\n{\n\tSize const total_subjects( all_occs.front().size() );\n\truntime_assert( subject_sampling_bias.size() == total_subjects );\n\truntime_assert( subject_indices.size() == total_subjects );\n\n\tReals avg_counts( total_subjects, 0. );\n\tReal diff_score_mean, diff_score_sdev;\n\n\tbools chosen( total_subjects ); // re-use this array\n\tSizes counts( total_subjects );\n\tReals realcounts( total_subjects );\n\n\n\tReals rand_diff_scores;\n\n\t// go through this loop 2*nrep times, building up the average the first time, then comparing the counts\n\t// \tto the average the second time, so we can get a Z-score for the observed counts\n\tfor ( Size rep=1; rep<= 2*nrep; ++rep ) {\n\t\tstd::fill( counts.begin(), counts.end(), Size(0) );\n\n\t\t// randomly choose tcr occurrences\n\t\tforeach_( Size t, tcrs ) {\n\t\t\tSize num_subjects_this_tcr(0);\n\t\t\tforeach_( bool occ, all_occs[t] ) { if ( occ ) ++num_subjects_this_tcr; }\n\t\t\tif ( num_subjects_this_tcr ) {\n\t\t\t\tchoose_random_subjects_with_bias( num_subjects_this_tcr, subject_sampling_bias, chosen );\n\t\t\t\tfor ( Size i=0; i< total_subjects; ++i ) {\n\t\t\t\t\tif ( chosen[i] ) ++counts[i];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tsort( counts.begin(), counts.end() ); // increasing order\n\t\tstd::reverse( counts.begin(), counts.end() ); // now decreasing order\n\n\t\tif ( rep <= nrep ) {\n\t\t\tfor ( Size i=0; i< total_subjects; ++i ) avg_counts[i] += counts[i];\n\n\t\t\tif ( rep == nrep ) { // normalize avg scores, write them out\n\t\t\t\tfor ( Size i=0; i< total_subjects; ++i ) avg_counts[i] /= nrep;\n\t\t\t\tout << \"avg_subject_tcr_counts\" << tag << \": total_subjects= \" << total_subjects;\n\t\t\t\tfor ( Size i=0; i< total_subjects; ++i ) out << ' ' << F(9,3,avg_counts[i]);\n\t\t\t\tout << '\\n';\n\t\t\t}\n\t\t} else {\n\t\t\t/// score our counts against avg_counts\n\t\t\tfor ( Size i=0; i< total_subjects; ++i ) realcounts[i] = Real(counts[i]);\n\n\t\t\tSize tmp_switchpoint;\n\t\t\tReal pos_score( score_l1_versus_l2( realcounts, avg_counts, tmp_switchpoint ) ),\n\t\t\t\tneg_score( score_l1_versus_l2( avg_counts, realcounts, tmp_switchpoint ) );\n\n\t\t\tif ( pos_score > neg_score ) {\n\t\t\t\trand_diff_scores.push_back( pos_score );\n\t\t\t} else {\n\t\t\t\trand_diff_scores.push_back( -1 * neg_score );\n\t\t\t}\n\t\t\truntime_assert( rand_diff_scores.size() == rep-nrep );\n\t\t}\n\t} // rep=1, 2*nrep\n\truntime_assert( rand_diff_scores.size() == nrep );\n\tget_mean_sdev( rand_diff_scores, diff_score_mean, diff_score_sdev );\n\n\n\tSizes subject_tcr_counts( total_subjects, 0 );\n\tfor ( Size i=0; i< tcrs.size(); ++i ) {\n\t\tbools const & i_occs( all_occs[ tcrs[i] ] );\n\t\tfor ( Size k=0; k< total_subjects; ++k ) {\n\t\t\tif ( i_occs[k] ) ++subject_tcr_counts[k];\n\t\t}\n\t}\n\tSizePairs countslist;\n\tSize num_nonzero(0);\n\tfor ( Size k=0; k< total_subjects; ++k ) {\n\t\tif ( subject_tcr_counts[k]>0 ) ++num_nonzero;\n\t\tcountslist.push_back( make_pair( subject_tcr_counts[k], k ) );\n\t}\n\tsort( countslist.begin(), countslist.end () );\n\treverse( countslist.begin(), countslist.end () );\n\n\t//Reals realcounts( total_subjects, 0.0 );\n\tfor ( Size i=0; i< total_subjects; ++i ) {\n\t\trealcounts[i] = countslist[i].first;\n\t}\n\n\tSize pos_switchpoint, neg_switchpoint;\n\tReal pos_score( score_l1_versus_l2( realcounts, avg_counts, pos_switchpoint ) ),\n\t\tneg_score( score_l1_versus_l2( avg_counts, realcounts, neg_switchpoint ) ),\n\t\tdiff_score( pos_score>neg_score ? pos_score : -1*neg_score ),\n\t\tdiff_Zscore( ( diff_score - diff_score_mean )/ diff_score_sdev );\n\n\tupper_tcr_count = countslist[ pos_switchpoint ].first;\n\tlower_tcr_count = ( pos_switchpoint < total_subjects ? countslist[ pos_switchpoint+1 ].first : 0 );\n\n\n\tout << \"subject_tcr_counts\" << tag << \": total_subjects= \" << total_subjects <<\n\t\t\" num_nonzero_tcr_counts: \" << num_nonzero <<\n\t\t\" D_CO: \" << F(9,3,diff_score) <<\n\t\t\" Z_CO: \" << F(9,3,diff_Zscore) <<\n\t\t\" D_CO_rand_mean: \" << F(9,3,diff_score_mean) <<\n\t\t\" D_CO_rand_sdev: \" << F(9,3,diff_score_sdev) <<\n\t\t\" pos_switchpoint: \" << pos_switchpoint <<\n\t\t\" upper_tcr_count: \" << upper_tcr_count <<\n\t\t\" lower_tcr_count: \" << lower_tcr_count;\n\t// Sizes const & hla_subs( hla_positive_subjects.find(hla)->second );\n\t// runtime_assert( hla_subs.size() == total_subjects );\n\tfor ( Size k=0; k< total_subjects; ++k ) {\n\t\tif ( countslist[k].first == 0 ) break; // don't show the zeros\n\t\tSize const subject( subject_indices[ countslist[k].second ] );\n\t\tout << ' ' << subject << ':' << countslist[k].first;\n\t\t\t//<< ':' << subject_sampling_bias[ countslist[k].second ]; // now show the bias...\n\t}\n\tout << '\\n';\n\n\treturn diff_Zscore;\n}\n\n////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n//\n// returns 1 if we don't have info for this (similarity_mode,nbr_pval_threshold)\n//\n//\n// probability of seeing an equal or greater number of neighbors for a random TCR, given num_clustered_tcrs\n//\nReal\ncompute_cluster_size_score(\n\tSize const num_center_nbrs, // max nbr number for cluster member\n\tSize const num_clustered_tcrs,\n\tSize const similarity_mode,\n\tReal const nbr_pval_threshold\n)\n{\n\tusing namespace boost::math;\n\tstatic bool init( false );\n\tstatic map< pair, Reals > precomputed_nbr_rates;\n\n\tif ( !init ) {\n\t\tinit = true;\n\t\tstring const filename( misc::dbdir + \"nbr_rates_for_P_size_calc.txt\" );\n\t\tstrings lines;\n\t\tread_lines_from_file( filename, lines );\n\t\tforeach_( string line, lines ) {\n\t\t\tistringstream l(line);\n\t\t\tstring tmp;\n\t\t\tSize l_sim_mode;\n\t\t\tReal l_nbr_pval_threshold;\n\t\t\tl >> tmp >> l_sim_mode >> tmp >> l_nbr_pval_threshold >> tmp;\n\t\t\tReals nbr_rates;\n\t\t\twhile ( !l.fail() ) {\n\t\t\t\tReal rate;\n\t\t\t\tl >> rate;\n\t\t\t\tif ( !l.fail() ) nbr_rates.push_back( rate );\n\t\t\t}\n\t\t\tcout << \"Read \" << nbr_rates.size() << \" precomputed_nbr_rates for similarity_mode: \" << l_sim_mode <<\n\t\t\t\t\" and nbr_pval_threshold: \" << l_nbr_pval_threshold << endl;\n\t\t\tprecomputed_nbr_rates[ make_pair( l_sim_mode, l_nbr_pval_threshold ) ] = nbr_rates;\n\t\t}\n\t}\n\n\tReals nbr_rates;\n\n\tif ( similarity_mode == 1 ) {\n\t\tnbr_rates.push_back( nbr_pval_threshold );\n\t} else { // look for info in the file\n\t\tfor ( map< pair, Reals >::const_iterator it= precomputed_nbr_rates.begin();\n\t\t\t\t\tit!= precomputed_nbr_rates.end(); ++it ) {\n\t\t\tif ( it->first.first == similarity_mode && fabs( log( it->first.second ) - log( nbr_pval_threshold ) )<.1 ) {\n\t\t\t\t// match\n\t\t\t\tnbr_rates = it->second;\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( nbr_rates.empty() ) {\n\t\tcerr << \"Failed to find precomputed information for computing cluster size score:: \" <<\n\t\t\t\" similarity_mode: \" << similarity_mode << \" nbr_pval_threshold: \" << nbr_pval_threshold << endl;\n\t\treturn 1.0;\n\t}\n\n\t//\n\tReal P_size(0); // odds of seeing an equal or greater neighbor number, given the total number of tcrs clustered\n\n\tReal const wt( 1.0/ nbr_rates.size() );\n\tforeach_( Real rate, nbr_rates ) {\n\t\tP_size += wt * cdf( complement( binomial( num_clustered_tcrs-1, rate ), num_center_nbrs-1 ) );\n\t}\n\n\treturn P_size;\n}\n\n#endif\n", "meta": {"hexsha": "6994a3d0d8961ef2faca5681ef9be08c7b9129b9", "size": 9119, "ext": "hh", "lang": "C++", "max_stars_repo_path": "src/cluster_scores.hh", "max_stars_repo_name": "wangshun1121/pubtcrs", "max_stars_repo_head_hexsha": "779ceca2e19c03d5172010527da8d7bf9c8d5923", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/cluster_scores.hh", "max_issues_repo_name": "wangshun1121/pubtcrs", "max_issues_repo_head_hexsha": "779ceca2e19c03d5172010527da8d7bf9c8d5923", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/cluster_scores.hh", "max_forks_repo_name": "wangshun1121/pubtcrs", "max_forks_repo_head_hexsha": "779ceca2e19c03d5172010527da8d7bf9c8d5923", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.026119403, "max_line_length": 120, "alphanum_fraction": 0.6504002632, "num_tokens": 2610, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6513548511303338, "lm_q2_score": 0.5350984286266115, "lm_q1q2_score": 0.34853895731816203}} {"text": "#include \n#include \n#include \n#include \"CftData.h\"\n#include \"common.h\"\n#include \n\nstd::ostream& operator<< (std::ostream& out, const CftConfig& config)\n{\n out << \"{D=\" << config.D << \", OperatorNumbers=\" << config.OperatorNumbers << '}';\n return out;\n}\n\nCftData::CftData(CftConfig config)\n{\n this->D = config.D;\n this->opsNumbers = config.OperatorNumbers;\n GenerateRandomData();\n}\n\nvoid CftData::GenerateRandomData()\n{\n // clear the data.\n ops.clear();\n opeCoefs.clear();\n\n // add Identity operator.\n ops.push_back(PrimaryInfo(0, 0, 0));\n\n int id = 0;\n for (uint i = 0; i < this->opsNumbers.size(); i++) {\n float_type lastDim = .0;\n float_type gap;\n\n // the unitary bound.\n if (i == 0) {\n gap = this->D / 2.0 - 1;\n } else {\n gap = i + this->D - 2.0;\n }\n\n for (int j = 0; j < this->opsNumbers[i]; j++) {\n double dim;\n id++;\n // for stress tensor\n if (i == 2 && j == 0) {\n dim = (double)this->D;\n } else {\n // randomly set scaling dimsion for primaries except for that\n // scaling dimesions increase with id.\n dim = lastDim + gap + random(0, .2);\n }\n\n gap = .8;\n\n ops.push_back(PrimaryInfo(id, dim, i));\n lastDim = dim;\n }\n }\n\n // randomly generate OPE coefficients for three scalars operators and two scalars and one spinning operators..\n for (int i = 1; i <= this->opsNumbers[0]; i++) {\n for (int j = i; j <= this->opsNumbers[0]; j++) {\n for (uint k = j; k <= this->ops.size(); k++) {\n SetOpeCoefficient(this->ops[i].Id, this->ops[j].Id, this->ops[k].Id, random(-5.0, 5.0));\n }\n }\n }\n\n SetFixedCftData();\n}\n\nvoid CftData::SetFixedCftData()\n{\n maxPrimaryId = Sum(opsNumbers);\n this->StressTensorId = opsNumbers[0] + opsNumbers[1] + 1;\n\n // normalize OPE coefficients of two identitical scalars to identity operator or stress tensor.\n // for identity operator the OPE coefficients are 1.\n // for stress tensor, it is -d * Dim/(d-1) * 1/S_d, where S_d is is the volumn of the unit sphere S^(d-1).\n float_type Pi = acos(-1.0);\n for (int i = 0; i <= opsNumbers[0]; i++) {\n SetOpeCoefficient(i, i, 0, 1.0);\n if (i > 0) {\n double coef = -D * GetPrimaryDim(i) / (D - 1);\n double sd = 2 * pow(Pi, D/2.0) / boost::math::tgamma(D/2.0);\n SetOpeCoefficient(i, i, StressTensorId, coef / sd);\n }\n\n for (int j = i + 1; j <= opsNumbers[0]; j++) {\n SetOpeCoefficient(i, j, 0, 0.0);\n SetOpeCoefficient(i, j, StressTensorId, 0.0);\n }\n }\n}\n\nPrimaryInfo CftData::GetPrimaryInfo(int id) const\n{\n return this->ops[id];\n}\n\nvoid CftData::SetPrimaryDim(int id, double dim)\n{\n this->ops[id].Dim = dim;\n}\n\nint CftData::PrimaryNumber(int spin) const\n{\n return this->opsNumbers[spin];\n}\n\nfloat_type CftData::GetOpeCoefficient(int id1, int id2, int id3)\n{\n return this->opeCoefs[OpeCoefficientKey(id1, id2, id3)];\n}\n\nfloat_type CftData::GetOpeCoefficient(OpeCoefficientKey& key)\n{\n return this->opeCoefs[key];\n}\n\nvoid CftData::SetOpeCoefficient(int id1, int id2, int id3, float_type coef)\n{\n this->opeCoefs[OpeCoefficientKey(id1, id2, id3)] = coef;\n}\n\nvoid CftData::SetOpeCoefficient(OpeCoefficientKey& key, float_type coef)\n{\n this->opeCoefs[key] = coef;\n}\n\nvoid CftData::Output(vector ops)\n{\n std::cout << \"Dimensions of operators\" << std::endl;\n for (uint i = 0; i < ops.size(); i++) {\n std::cout << ops[i] << \":\\t\" << GetPrimaryDim(ops[i]) << std::endl;\n }\n\n std::cout << std::endl << \"OPE coefficients: \" << std::endl;\n\n int count = 0;\n\n for (uint i = 0; i < ops.size(); i++) {\n for (uint j = i; j < ops.size(); j++) {\n for (uint k = j; k < ops.size(); k++) {\n std::cout << '(' << ops[i] << ',' << ops[j] << ',' << ops[k] << \"): \";\n std::cout << GetOpeCoefficient(ops[i], ops[j], ops[k]) << \"\\t\";\n count++;\n if (count % 5 == 0) std::cout << endl;\n }\n }\n }\n std::cout << std::endl;\n}\n\nvoid CftData::Save(string file)\n{\n ofstream out(file);\n out << this->D << ' ' << this->opsNumbers.size() << std::endl;\n\n out << \"OperatorNubmers:\" << std::endl;\n for (uint i = 0; i < this->opsNumbers.size(); i++) {\n if (i > 0) out << ' ';\n out << opsNumbers[i];\n }\n out << std::endl;\n \n out << \"ScalingDimensions:\" << std::endl;\n for (uint i = 1; i < ops.size(); i++) {\n if (i > 1) out << ' ';\n out << setprecision(15) << ops[i].Dim;\n }\n out << std::endl;\n\n out << \"OpeCoefficients:\" << std::endl;\n for (int i = 1; i <= this->opsNumbers[0]; i++) {\n for (int j = i; j <= this->opsNumbers[0]; j++) {\n for (uint k = j; k < this->ops.size(); k++) {\n if (k == StressTensorId) continue;\n out << i << ' ' << j << ' ' << k << ' ' << setprecision(15) << GetOpeCoefficient(i, j, k) << std::endl;\n }\n }\n }\n\n out.close();\n}\n\nvoid CftData::LoadFromFile(string file)\n{\n ifstream in(file);\n int spinNumber;\n string buf;\n in >> this->D >> spinNumber;\n this->opsNumbers.resize(spinNumber, 0);\n\n in >> buf;\n for (int i = 0; i < spinNumber; i++) {\n in >> opsNumbers[i];\n }\n \n in >> buf;\n\n int id = 0;\n float_type dim;\n ops.clear();\n ops.push_back(PrimaryInfo(id, 0.0, 0));\n for (int spin = 0; spin < spinNumber; spin++) {\n for (int i = 0; i < opsNumbers[spin]; i++) {\n in >> dim;\n ops.push_back(PrimaryInfo(++id, dim, spin));\n }\n }\n\n in >> buf;\n\n int op1, op2, op3;\n float_type coef;\n while(!in.eof()) {\n in >> op1 >> op2 >> op3 >> coef;\n if (!in.good()) break;\n SetOpeCoefficient(op1, op2, op3, coef);\n }\n\n in.close();\n\n SetFixedCftData();\n}\n\n", "meta": {"hexsha": "2c1574ca26761ec4e9093bbf33e91e3d67fdff62", "size": 6139, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/CftData.cpp", "max_stars_repo_name": "gaolichen/cftbtsp", "max_stars_repo_head_hexsha": "e764b6ca339d6d68a5c6b6acd9f58ef64c628d47", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/CftData.cpp", "max_issues_repo_name": "gaolichen/cftbtsp", "max_issues_repo_head_hexsha": "e764b6ca339d6d68a5c6b6acd9f58ef64c628d47", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/CftData.cpp", "max_forks_repo_name": "gaolichen/cftbtsp", "max_forks_repo_head_hexsha": "e764b6ca339d6d68a5c6b6acd9f58ef64c628d47", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.807860262, "max_line_length": 119, "alphanum_fraction": 0.5214204268, "num_tokens": 1841, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7025300573952054, "lm_q2_score": 0.49609382947091946, "lm_q1q2_score": 0.34852082649161226}} {"text": "/*********************************************************************************\n * OKVIS - Open Keyframe-based Visual-Inertial SLAM\n * Copyright (c) 2015, Autonomous Systems Lab / ETH Zurich\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following disclaimer in the documentation\n * and/or other materials provided with the distribution.\n * * Neither the name of Autonomous Systems Lab / ETH Zurich nor the names of\n * its contributors may be used to endorse or promote products derived from\n * this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n *\n * Created on: Feb 3, 2015\n * Author: Stefan Leutenegger (s.leutenegger@imperial.ac.uk)\n *********************************************************************************/\n\n/**\n * @file implementation/EquidistantDistortion.hpp\n * @brief Header implementation file for the EquidistantDistortion class.\n * @author Stefan Leutenegger\n */\n\n\n#include \n#include \n\n/// \\brief okvis Main namespace of this package.\nnamespace vio {\n/// \\brief cameras Namespace for camera-related functionality.\nnamespace cameras {\n int FTR_UNDIST_DL_MAX_ITERATIONS = 10;\n float FTR_UNDIST_DL_RADIUS_INITIAL = 1.0f; // 1.0^2\n float FTR_UNDIST_DL_RADIUS_MIN = 1.0e-10f; // 0.00001^2\n float FTR_UNDIST_DL_RADIUS_MAX = 1.0e4f; // 100.0^2\n float FTR_UNDIST_DL_RADIUS_FACTOR_INCREASE = 9.0f; // 3.0^2\n float FTR_UNDIST_DL_RADIUS_FACTOR_DECREASE = 0.25f; // 0.5^2\n float FTR_UNDIST_DL_GAIN_RATIO_MIN = 0.25f;\n float FTR_UNDIST_DL_GAIN_RATIO_MAX = 0.75f;\n// The default constructor with all zero ki\nEquidistantDistortion::EquidistantDistortion()\n : k1_(0.0),\n k2_(0.0),\n k3_(0.0),\n k4_(0.0)\n{\n parameters_.setZero();\n}\n\n// Constructor initialising ki\nEquidistantDistortion::EquidistantDistortion(float k1, float k2, float k3,\n float k4)\n{\n parameters_[0] = k1;\n parameters_[1] = k2;\n parameters_[2] = k3;\n parameters_[3] = k4;\n k1_ = k1;\n k2_ = k2;\n k3_ = k3;\n k4_ = k4;\n}\n\nbool EquidistantDistortion::setParameters(const Eigen::VectorXd & parameters)\n{\n if (parameters.cols() != NumDistortionIntrinsics) {\n return false;\n }\n parameters_ = parameters.cast();;\n k1_ = parameters[0];\n k2_ = parameters[1];\n k3_ = parameters[2];\n k4_ = parameters[3];\n return true;\n}\n\nbool EquidistantDistortion::distort(const Eigen::Vector2d & pointUndistorted,\n Eigen::Vector2d * pointDistorted) const\n{\n // distortion only:\n const float u0 = pointUndistorted[0];\n const float u1 = pointUndistorted[1];\n const float r = sqrt(u0 * u0 + u1 * u1);\n const float theta = atan(r);\n const float theta2 = theta * theta;\n const float theta4 = theta2 * theta2;\n const float theta6 = theta4 * theta2;\n const float theta8 = theta4 * theta4;\n const float thetad = theta\n * (1 + k1_ * theta2 + k2_ * theta4 + k3_ * theta6 + k4_ * theta8);\n\n const float scaling = (r > 1e-8) ? thetad / r : 1.0;\n (*pointDistorted)[0] = scaling * u0;\n (*pointDistorted)[1] = scaling * u1;\n return true;\n}\n\nbool EquidistantDistortion::distort(const Eigen::Vector2f & pointUndistorted,\n Eigen::Vector2f * pointDistorted) const\n{\n // distortion only:\n const float u0 = pointUndistorted[0];\n const float u1 = pointUndistorted[1];\n const float r = sqrt(u0 * u0 + u1 * u1);\n const float theta = atan(r);\n const float theta2 = theta * theta;\n const float theta4 = theta2 * theta2;\n const float theta6 = theta4 * theta2;\n const float theta8 = theta4 * theta4;\n const float thetad = theta\n * (1 + k1_ * theta2 + k2_ * theta4 + k3_ * theta6 + k4_ * theta8);\n\n const float scaling = (r > 1e-8) ? thetad / r : 1.0;\n (*pointDistorted)[0] = scaling * u0;\n (*pointDistorted)[1] = scaling * u1;\n return true;\n}\n\nbool EquidistantDistortion::distort(const Eigen::Vector2d & pointUndistorted,\n Eigen::Vector2d * pointDistorted,\n Eigen::Matrix2d * pointJacobian,\n Eigen::Matrix2Xd * parameterJacobian) const\n{\n // distortion first:\n const float u0 = pointUndistorted[0];\n const float u1 = pointUndistorted[1];\n const float r = sqrt(u0 * u0 + u1 * u1);\n const float theta = atan(r);\n const float theta2 = theta * theta;\n const float theta4 = theta2 * theta2;\n const float theta6 = theta4 * theta2;\n const float theta8 = theta4 * theta4;\n const float thetad = theta\n * (1 + k1_ * theta2 + k2_ * theta4 + k3_ * theta6 + k4_ * theta8);\n\n const float scaling = (r > 1e-8) ? thetad / r : 1.0;\n (*pointDistorted)[0] = scaling * u0;\n (*pointDistorted)[1] = scaling * u1;\n\n Eigen::Matrix2d & J = *pointJacobian;\n if (r > 1e-8) {\n // mostly matlab generated...\n float t2;\n float t3;\n float t4;\n float t6;\n float t7;\n float t8;\n float t9;\n float t11;\n float t17;\n float t18;\n float t19;\n float t20;\n float t25;\n\n t2 = u0 * u0;\n t3 = u1 * u1;\n t4 = t2 + t3;\n t6 = atan(sqrt(t4));\n t7 = t6 * t6;\n t8 = 1.0 / sqrt(t4);\n t9 = t7 * t7;\n t11 = 1.0 / ((t2 + t3) + 1.0);\n t17 = (((k1_ * t7 + k2_ * t9) + k3_ * t7 * t9) + k4_ * (t9 * t9)) + 1.0;\n t18 = 1.0 / t4;\n t19 = 1.0 / sqrt(t4 * t4 * t4);\n t20 = t6 * t8 * t17;\n t25 = ((k2_ * t6 * t7 * t8 * t11 * u1 * 4.0\n + k3_ * t6 * t8 * t9 * t11 * u1 * 6.0)\n + k4_ * t6 * t7 * t8 * t9 * t11 * u1 * 8.0)\n + k1_ * t6 * t8 * t11 * u1 * 2.0;\n t4 = ((k2_ * t6 * t7 * t8 * t11 * u0 * 4.0\n + k3_ * t6 * t8 * t9 * t11 * u0 * 6.0)\n + k4_ * t6 * t7 * t8 * t9 * t11 * u0 * 8.0)\n + k1_ * t6 * t8 * t11 * u0 * 2.0;\n t7 = t11 * t17 * t18 * u0 * u1;\n J(0, 1) = (t7 + t6 * t8 * t25 * u0) - t6 * t17 * t19 * u0 * u1;\n J(1, 1) = ((t20 - t3 * t6 * t17 * t19) + t3 * t11 * t17 * t18)\n + t6 * t8 * t25 * u1;\n J(0, 0) = ((t20 - t2 * t6 * t17 * t19) + t2 * t11 * t17 * t18)\n + t6 * t8 * t4 * u0;\n J(1, 0) = (t7 + t6 * t8 * t4 * u1) - t6 * t17 * t19 * u0 * u1;\n\n if (parameterJacobian) {\n Eigen::Matrix2Xd & Ji = *parameterJacobian;\n Ji.resize(2,NumDistortionIntrinsics);\n // mostly matlab generated...\n float t6;\n float t2;\n float t3;\n float t8;\n float t10;\n\n t6 = u0 * u0 + u1 * u1;\n t2 = atan(sqrt(t6));\n t3 = t2 * t2;\n t8 = t3 * t3;\n t6 = 1.0 / sqrt(t6);\n t10 = t8 * t8;\n Ji(0, 0) = t2 * t3 * t6 * u0;\n Ji(1, 0) = t2 * t3 * t6 * u1;\n Ji(0, 1) = t2 * t8 * t6 * u0;\n Ji(1, 1) = t2 * t8 * t6 * u1;\n Ji(0, 2) = t2 * t3 * t8 * t6 * u0;\n Ji(1, 2) = t2 * t3 * t8 * t6 * u1;\n Ji(0, 3) = t2 * t6 * t10 * u0;\n Ji(1, 3) = t2 * t6 * t10 * u1;\n\n }\n } else {\n // handle limit case for [u0,u1]->0\n if (parameterJacobian) {\n parameterJacobian->resize(2,NumDistortionIntrinsics);\n parameterJacobian->setZero();\n }\n J.setIdentity();\n }\n\n return true;\n}\n\n\nbool EquidistantDistortion::distort(const Eigen::Vector2f & pointUndistorted,\n Eigen::Vector2f* pointDistorted,\n Eigen::Matrix2f * pointJacobian,\n Eigen::Matrix2Xf * parameterJacobian) const\n{\n\n\n ////针对k1,k2,k2,k3的等距投影模型, r^2 = x^2 + y^2\n ////残差2*1 归一化坐标的2维： min F(x,y) = 0.5*r(x,y)^2 约束： x^2+y^2 <=\n /// r.x = x*(theta*(1 + k1*theta^2 + k2*theta^4 + k3 *theta^6 + k4*theta^8)/r) - x0\n //// r.x = y*(theta*(1 + k1*theta^2 + k2*theta^4 + k3 *theta^6 + k4*theta^8)/r) - y0\n // distortion first:\n const float u0 = pointUndistorted[0];//x\n const float u1 = pointUndistorted[1];//y\n const float r = sqrt(u0 * u0 + u1 * u1);//r = sqrt(x^2 + y^2)\n const float theta = atan(r);\n const float theta2 = theta * theta;\n const float theta4 = theta2 * theta2;\n const float theta6 = theta4 * theta2;\n const float theta8 = theta4 * theta4;\n const float thetad = theta\n * (1 + k1_ * theta2 + k2_ * theta4 + k3_ * theta6 + k4_ * theta8);\n\n const float scaling = (r > 1e-8) ? thetad / r : 1.0;\n (*pointDistorted)[0] = scaling * u0;\n (*pointDistorted)[1] = scaling * u1;\n\n Eigen::Matrix2f & J = *pointJacobian;\n if (r > 1e-8) {\n // mostly matlab generated...\n float t2;//x^2\n float t3;//y^2\n float t4;//r^2 = x^2+y^2\n float t6;//theta\n float t7;//theta^2\n float t8;// 1/r\n float t9;//theta^4\n float t11;// 1 / ((x^2+y^2) + 1.0);\n float t17;// (((k1_ * theta^2 + k2_ * theta^4) + k3_ * t7 * t9) + k4_ * (t9 * t9)) + 1.0\n float t18;\n float t19;\n float t20;\n float t25;\n\n t2 = u0 * u0;\n t3 = u1 * u1;\n t4 = t2 + t3;\n t6 = atan(sqrt(t4));\n t7 = t6 * t6;\n t8 = 1.0 / sqrt(t4);\n t9 = t7 * t7;\n t11 = 1.0 / ((t2 + t3) + 1.0);\n t17 = (((k1_ * t7 + k2_ * t9) + k3_ * t7 * t9) + k4_ * (t9 * t9)) + 1.0;\n t18 = 1.0 / t4;\n t19 = 1.0 / sqrt(t4 * t4 * t4);\n t20 = t6 * t8 * t17;\n t25 = ((k2_ * t6 * t7 * t8 * t11 * u1 * 4.0\n + k3_ * t6 * t8 * t9 * t11 * u1 * 6.0)\n + k4_ * t6 * t7 * t8 * t9 * t11 * u1 * 8.0)\n + k1_ * t6 * t8 * t11 * u1 * 2.0;\n t4 = ((k2_ * t6 * t7 * t8 * t11 * u0 * 4.0\n + k3_ * t6 * t8 * t9 * t11 * u0 * 6.0)\n + k4_ * t6 * t7 * t8 * t9 * t11 * u0 * 8.0)\n + k1_ * t6 * t8 * t11 * u0 * 2.0;\n t7 = t11 * t17 * t18 * u0 * u1;\n J(0, 1) = (t7 + t6 * t8 * t25 * u0) - t6 * t17 * t19 * u0 * u1;\n J(1, 1) = ((t20 - t3 * t6 * t17 * t19) + t3 * t11 * t17 * t18)\n + t6 * t8 * t25 * u1;\n J(0, 0) = ((t20 - t2 * t6 * t17 * t19) + t2 * t11 * t17 * t18)\n + t6 * t8 * t4 * u0;\n J(1, 0) = (t7 + t6 * t8 * t4 * u1) - t6 * t17 * t19 * u0 * u1;\n\n if (parameterJacobian) {\n Eigen::Matrix2Xf & Ji = *parameterJacobian;\n Ji.resize(2,NumDistortionIntrinsics);\n // mostly matlab generated...\n float t6;\n float t2;\n float t3;\n float t8;\n float t10;\n\n t6 = u0 * u0 + u1 * u1;\n t2 = atan(sqrt(t6));\n t3 = t2 * t2;\n t8 = t3 * t3;\n t6 = 1.0 / sqrt(t6);\n t10 = t8 * t8;\n Ji(0, 0) = t2 * t3 * t6 * u0;\n Ji(1, 0) = t2 * t3 * t6 * u1;\n Ji(0, 1) = t2 * t8 * t6 * u0;\n Ji(1, 1) = t2 * t8 * t6 * u1;\n Ji(0, 2) = t2 * t3 * t8 * t6 * u0;\n Ji(1, 2) = t2 * t3 * t8 * t6 * u1;\n Ji(0, 3) = t2 * t6 * t10 * u0;\n Ji(1, 3) = t2 * t6 * t10 * u1;\n\n }\n } else {\n // handle limit case for [u0,u1]->0\n if (parameterJacobian) {\n parameterJacobian->resize(2,NumDistortionIntrinsics);\n parameterJacobian->setZero();\n }\n J.setIdentity();\n }\n\n return true;\n}\n\n\nbool EquidistantDistortion::distortWithExternalParameters(\n const Eigen::Vector2d & pointUndistorted,\n const Eigen::VectorXd & parameters, Eigen::Vector2d * pointDistorted,\n Eigen::Matrix2d * pointJacobian, Eigen::Matrix2Xd * parameterJacobian) const\n{\n // decompose parameters\n\n const float k1 = parameters[0];\n const float k2 = parameters[1];\n const float k3 = parameters[2];\n const float k4 = parameters[3];\n // distortion first:\n const float u0 = pointUndistorted[0];\n const float u1 = pointUndistorted[1];\n const float r = sqrt(u0 * u0 + u1 * u1);\n const float theta = atan(r);\n const float theta2 = theta * theta;\n const float theta4 = theta2 * theta2;\n const float theta6 = theta4 * theta2;\n const float theta8 = theta4 * theta4;\n const float thetad = theta\n * (1 + k1 * theta2 + k2 * theta4 + k3 * theta6 + k4 * theta8);\n\n const float scaling = (r > 1e-8) ? thetad / r : 1.0;\n (*pointDistorted)[0] = scaling * u0;\n (*pointDistorted)[1] = scaling * u1;\n\n Eigen::Matrix2d & J = *pointJacobian;\n if (r > 1e-8) {\n // mostly matlab generated...\n float t2;\n float t3;\n float t4;\n float t6;\n float t7;\n float t8;\n float t9;\n float t11;\n float t17;\n float t18;\n float t19;\n float t20;\n float t25;\n\n t2 = u0 * u0;\n t3 = u1 * u1;\n t4 = t2 + t3;\n t6 = atan(sqrt(t4));\n t7 = t6 * t6;\n t8 = 1.0 / sqrt(t4);\n t9 = t7 * t7;\n t11 = 1.0 / ((t2 + t3) + 1.0);\n t17 = (((k1 * t7 + k2 * t9) + k3 * t7 * t9) + k4 * (t9 * t9)) + 1.0;\n t18 = 1.0 / t4;\n t19 = 1.0 / sqrt(t4 * t4 * t4);\n t20 = t6 * t8 * t17;\n t25 = ((k2 * t6 * t7 * t8 * t11 * u1 * 4.0\n + k3 * t6 * t8 * t9 * t11 * u1 * 6.0)\n + k4 * t6 * t7 * t8 * t9 * t11 * u1 * 8.0)\n + k1 * t6 * t8 * t11 * u1 * 2.0;\n t4 = ((k2 * t6 * t7 * t8 * t11 * u0 * 4.0\n + k3 * t6 * t8 * t9 * t11 * u0 * 6.0)\n + k4 * t6 * t7 * t8 * t9 * t11 * u0 * 8.0)\n + k1 * t6 * t8 * t11 * u0 * 2.0;\n t7 = t11 * t17 * t18 * u0 * u1;\n J(0, 0) = (t7 + t6 * t8 * t25 * u0) - t6 * t17 * t19 * u0 * u1;\n J(1, 0) = ((t20 - t3 * t6 * t17 * t19) + t3 * t11 * t17 * t18)\n + t6 * t8 * t25 * u1;\n J(0, 1) = ((t20 - t2 * t6 * t17 * t19) + t2 * t11 * t17 * t18)\n + t6 * t8 * t4 * u0;\n J(1, 1) = (t7 + t6 * t8 * t4 * u1) - t6 * t17 * t19 * u0 * u1;\n if (parameterJacobian) {\n Eigen::Matrix2Xd & Ji = *parameterJacobian;\n Ji.resize(2,NumDistortionIntrinsics);\n // mostly matlab generated...\n float t6;\n float t2;\n float t3;\n float t8;\n float t10;\n\n t6 = u0 * u0 + u1 * u1;\n t2 = atan(sqrt(t6));\n t3 = t2 * t2;\n t8 = t3 * t3;\n t6 = 1.0 / sqrt(t6);\n t10 = t8 * t8;\n Ji(0, 0) = t2 * t3 * t6 * u0;\n Ji(1, 0) = t2 * t3 * t6 * u1;\n Ji(0, 1) = t2 * t8 * t6 * u0;\n Ji(1, 1) = t2 * t8 * t6 * u1;\n Ji(0, 2) = t2 * t3 * t8 * t6 * u0;\n Ji(1, 2) = t2 * t3 * t8 * t6 * u1;\n Ji(0, 3) = t2 * t6 * t10 * u0;\n Ji(1, 3) = t2 * t6 * t10 * u1;\n\n }\n } else {\n // handle limit case for [u0,u1]->0\n if (parameterJacobian) {\n parameterJacobian->resize(2,NumDistortionIntrinsics);\n parameterJacobian->setZero();\n }\n J.setIdentity();\n }\n\n return true;\n}\nbool EquidistantDistortion::undistort(const Eigen::Vector2d & pointDistorted,\n Eigen::Vector2d * pointUndistorted) const\n{\n // this is expensive: we solve with Gauss-Newton...\n Eigen::Vector2d x_bar = pointDistorted; // initialise at distorted point\n const int n = 5; // just 5 iterations max.\n Eigen::Matrix2d E; // error Jacobian\n\n bool success = false;\n for (int i = 0; i < n; i++) {\n\n Eigen::Vector2d x_tmp;\n\n distort(x_bar, &x_tmp, &E);\n\n Eigen::Vector2d e(pointDistorted - x_tmp);//Hx = b=>\n Eigen::Vector2d du = (E.transpose() * E).inverse() * E.transpose() * e;\n\n x_bar += du;\n\n\n const double chi2 = e.dot(e);\n if (chi2 < 1e-2) {\n success = true;\n }\n //std::cout<<\"chi2\"< delta2 && dx2GD == 0.0f) {//如果G-N增量在信赖域外且dx2GD还没有初始化\n// const float bl = sqrtf(b.squaredNorm());//模长\n// const Eigen::Vector2f g = b * (1.0f / bl);//梯度方向\n// const Eigen::Vector2f Ag = A * g;\n// const float xl = bl / g.dot(Ag);//计算pU点的步长\n// dxGD = g * -xl;//负梯度*步长,pU点\n// dx2GD = xl * xl;//pU点的半径\n//\n// }\n// //三种情况,1：GN极值点在域内直接变成无约束条件 2:GN和pU点都在域外,那么就在给pU点的步长一个比例因子(域半径/自己的步长^2（因为用的是最小2乘）),让它刚好落在域半径上\n// //3:GN在域外,pU点在域内,那么增量就是GN极值点和pU点的连线与信赖域的交点\n// if (dx2GN <= delta2) {//如果G-N的极值在信赖域内,那么就是一个无约束问题,就直接用GN法求出的增量就可以\n// dx = dxGN;\n// dx2 = dx2GN;\n// beta = 1.0f;\n// } else if (dx2GD >= delta2) {//如果G-N和pU点求的最优点都在信赖域外\n// if (delta2 == 0.0f) {//信赖域为0,直接用pU点求得最优值\n// dx = dxGD;\n// dx2 = dx2GD;\n// } else {\n// dx = dxGD * sqrtf(delta2 / dx2GD);//乘比例因子\n// dx2 = delta2;\n// }\n// beta = 0.0f;\n// } else {//GN在域外,pU点在域内,那么增量就是GN极值点和pU点的连线与信赖域的交点\n// const Eigen::Vector2f v = dxGN - dxGD;//方向\n// const float d = dxGD.dot(v), v2 = v.squaredNorm();\n// //beta = float((-d + sqrt(double(d) * d + (delta2 - dx2GD) * double(v2))) / v2);\n// beta = (-d + sqrtf(d * d + (delta2 - dx2GD) * v2)) / v2;//算得是在域外那段连线的长度\n// dx = dxGD;\n// dx += v * beta;\n// dx2 = delta2;\n// }\n// x_bar += dx;//加上这一次的增量\n// Eigen::Vector2f x_d_temp;\n// distort(x_bar, &x_d_temp);\n// const float dFa = F - (x_d_temp - pointDistorted).squaredNorm();//实际下降的\n// const float dFp = F - (e + ( E.transpose()) * dx).squaredNorm();//理论下降值,直接用J*dx近似下降值了\n// const float rho = dFa > 0.0f && dFp > 0.0f ? dFa / dFp : -1.0f;//求实际/理论的比值,理论不可能为负,实际为负的时候拒绝这次更新\n// //信赖域： Numerical Optimization 第二版 p69\n//\n// //rho < 0.25 如果大于0说明近似的不好,需要减小信赖域,减小近似的范围。如果<0就说明是错误的近似,那么就拒绝这次的增量\n// if (rho < FTR_UNDIST_DL_GAIN_RATIO_MIN) {\n// delta2 *= FTR_UNDIST_DL_RADIUS_FACTOR_DECREASE;\n// if (delta2 < FTR_UNDIST_DL_RADIUS_MIN) {\n// delta2 = FTR_UNDIST_DL_RADIUS_MIN;\n// }\n// x_bar = xnBkp;//取消这次增量\n// update = false;//不更新\n// converge = false;\n// continue;\n// } else if (rho > FTR_UNDIST_DL_GAIN_RATIO_MAX) //rho > 0.75,可以扩大信赖域半径\n// {\n// delta2 = std::max(delta2, FTR_UNDIST_DL_RADIUS_FACTOR_INCREASE * dx2);\n// if (delta2 > FTR_UNDIST_DL_RADIUS_MAX) {//信赖域半径最大值\n// delta2 = FTR_UNDIST_DL_RADIUS_MAX;\n// }\n// }\n// update = true;//\n//\n// converge = dx2 < 1e-12;//增量小于阈值,认为收敛\n// break;\n// }\n// if (!update || converge) {\n// break;\n// }\n//\n// const double chi2 = e.dot(e);\n// if (chi2 < 1e-5) {\n// success = true;\n// }\n const double chi2 = e.dot(e);\n\n if (chi2 < 1e-8) {\n success = true;\n break;\n }\n\n\n }\n *pointUndistorted = x_bar;\n if(converge)\n success = true;\n\n\n return success;\n}\n\nbool EquidistantDistortion::undistort(const Eigen::Vector2d & pointDistorted,\n Eigen::Vector2d * pointUndistorted,\n Eigen::Matrix2d * pointJacobian) const\n{\n // this is expensive: we solve with Gauss-Newton...\n Eigen::Vector2d x_bar = pointDistorted; // initialise at distorted point\n const int n = 5; // just 5 iterations max.\n Eigen::Matrix2d E; // error Jacobian\n\n bool success = false;\n for (int i = 0; i < n; i++) {\n\n Eigen::Vector2d x_tmp;\n\n distort(x_bar, &x_tmp, &E);\n\n Eigen::Vector2d e(pointDistorted - x_tmp);\n Eigen::Vector2d dx = (E.transpose() * E).inverse() * E.transpose() * e;\n\n x_bar += dx;\n\n const double chi2 = e.dot(e);\n if (chi2 < 1e-2) {\n success = true;\n }\n if (chi2 < 1e-15) {\n success = true;\n break;\n }\n\n }\n *pointUndistorted = x_bar;\n\n // the Jacobian of the inverse map is simply the inverse Jacobian.\n *pointJacobian = E.inverse();\n\n return success;\n}\n\nbool EquidistantDistortion::undistort(const Eigen::Vector2f & pointDistorted,\n Eigen::Vector2f * pointUndistorted,\n Eigen::Matrix2f * pointJacobian) const\n{\n // this is expensive: we solve with Gauss-Newton...\n Eigen::Vector2f x_bar = pointDistorted; // initialise at distorted point\n const int n = 5; // just 5 iterations max.\n Eigen::Matrix2f E; // error Jacobian\n\n bool success = false;\n for (int i = 0; i < n; i++) {\n\n Eigen::Vector2f x_tmp;\n\n distort(x_bar, &x_tmp, &E);\n\n Eigen::Vector2f e(pointDistorted - x_tmp);\n Eigen::Vector2f dx = (E.transpose() * E).inverse() * E.transpose() * e;\n\n x_bar += dx;\n\n const double chi2 = e.dot(e);\n if (chi2 < 1e-2) {\n success = true;\n }\n if (chi2 < 1e-15) {\n success = true;\n break;\n }\n\n }\n *pointUndistorted = x_bar;\n\n // the Jacobian of the inverse map is simply the inverse Jacobian.\n *pointJacobian = E.inverse();\n\n return success;\n}\n\n} // namespace cameras\n} // namespace okvis\n", "meta": {"hexsha": "dce8d870d0184eca3cdbcfe1b57b3fd4839d0f58", "size": 24689, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "Frontend/cameras/implementation/EquidistantDistortion.hpp", "max_stars_repo_name": "wangyuanbiubiubiu/ICE-BA-ros", "max_stars_repo_head_hexsha": "9a3582a2dd1d5ae24115425bdf072864094cfb8e", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 47.0, "max_stars_repo_stars_event_min_datetime": "2020-03-06T10:19:36.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T10:06:37.000Z", "max_issues_repo_path": "Frontend/cameras/implementation/EquidistantDistortion.hpp", "max_issues_repo_name": "wangyuanbiubiubiu/ICE-BA-Annotation", "max_issues_repo_head_hexsha": "9a3582a2dd1d5ae24115425bdf072864094cfb8e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2020-03-06T11:57:05.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-19T01:47:22.000Z", "max_forks_repo_path": "Frontend/cameras/implementation/EquidistantDistortion.hpp", "max_forks_repo_name": "wangyuanbiubiubiu/ICE-BA-Annotation", "max_forks_repo_head_hexsha": "9a3582a2dd1d5ae24115425bdf072864094cfb8e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 6.0, "max_forks_repo_forks_event_min_datetime": "2020-03-06T10:19:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-31T13:23:22.000Z", "avg_line_length": 34.9207920792, "max_line_length": 110, "alphanum_fraction": 0.5004252906, "num_tokens": 8463, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7025300573952052, "lm_q2_score": 0.49609382947091946, "lm_q1q2_score": 0.3485208264916122}} {"text": "/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */\n\n/*\n Copyright (C) 2008 Andreas Gaida\n Copyright (C) 2008 Ralph Schreyer\n Copyright (C) 2008 Klaus Spanderen\n\n This file is part of QuantLib, a free-software/open-source library\n for financial quantitative analysts and developers - http://quantlib.org/\n\n QuantLib is free software: you can redistribute it and/or modify it\n under the terms of the QuantLib license. You should have received a\n copy of the license along with this program; if not, please email\n . The license is also available online at\n .\n\n This program is distributed in the hope that it will be useful, but WITHOUT\n ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n FOR A PARTICULAR PURPOSE. See the license for more details.\n*/\n\n/*! \\file ninepointlinearop.hpp\n \\brief nine point linear operator\n*/\n\n#ifndef quantlib_nine_point_linear_op_hpp\n#define quantlib_nine_point_linear_op_hpp\n\n#include \n#include \n#if !defined(QL_USE_STD_UNIQUE_PTR)\n#include \n#endif\n#include \n\nnamespace QuantLib {\n\n class FdmMesher;\n\n class NinePointLinearOp : public FdmLinearOp {\n public:\n NinePointLinearOp(Size d0, Size d1,\n const ext::shared_ptr& mesher);\n NinePointLinearOp(const NinePointLinearOp& m);\n NinePointLinearOp(NinePointLinearOp&& m) QL_NOEXCEPT;\n #ifdef QL_USE_DISPOSABLE\n NinePointLinearOp(const Disposable& m);\n #endif\n NinePointLinearOp& operator=(const NinePointLinearOp& m);\n NinePointLinearOp& operator=(NinePointLinearOp&& m) QL_NOEXCEPT;\n #ifdef QL_USE_DISPOSABLE\n NinePointLinearOp& operator=(const Disposable& m);\n #endif\n\n Disposable apply(const Array& r) const override;\n Disposable mult(const Array& u) const;\n\n void swap(NinePointLinearOp& m);\n\n Disposable toMatrix() const override;\n\n protected:\n NinePointLinearOp() = default;\n\n Size d0_, d1_;\n #if !defined(QL_USE_STD_UNIQUE_PTR)\n boost::shared_array i00_, i10_, i20_;\n boost::shared_array i01_, i21_;\n boost::shared_array i02_, i12_, i22_;\n boost::shared_array a00_, a10_, a20_;\n boost::shared_array a01_, a11_, a21_;\n boost::shared_array a02_, a12_, a22_;\n #else\n std::unique_ptr i00_, i10_, i20_;\n std::unique_ptr i01_, i21_;\n std::unique_ptr i02_, i12_, i22_;\n std::unique_ptr a00_, a10_, a20_;\n std::unique_ptr a01_, a11_, a21_;\n std::unique_ptr a02_, a12_, a22_;\n #endif\n\n ext::shared_ptr mesher_;\n };\n\n\n inline NinePointLinearOp::NinePointLinearOp(NinePointLinearOp&& m) QL_NOEXCEPT {\n swap(m);\n }\n\n inline NinePointLinearOp& NinePointLinearOp::operator=(const NinePointLinearOp& m) {\n NinePointLinearOp temp(m);\n swap(temp);\n return *this;\n }\n\n inline NinePointLinearOp& NinePointLinearOp::operator=(NinePointLinearOp&& m) QL_NOEXCEPT {\n swap(m);\n return *this;\n }\n\n}\n\n#endif\n", "meta": {"hexsha": "f3402f36289fd23d15379fbb9caae095ff1ffd89", "size": 3429, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "ql/methods/finitedifferences/operators/ninepointlinearop.hpp", "max_stars_repo_name": "jiangjiali/QuantLib", "max_stars_repo_head_hexsha": "37c98eccfa18a95acb1e98b276831641be92b38e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3358.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T02:56:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T02:42:47.000Z", "max_issues_repo_path": "ql/methods/finitedifferences/operators/ninepointlinearop.hpp", "max_issues_repo_name": "jiangjiali/QuantLib", "max_issues_repo_head_hexsha": "37c98eccfa18a95acb1e98b276831641be92b38e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 965.0, "max_issues_repo_issues_event_min_datetime": "2015-12-21T10:35:28.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T02:47:00.000Z", "max_forks_repo_path": "ql/methods/finitedifferences/operators/ninepointlinearop.hpp", "max_forks_repo_name": "jiangjiali/QuantLib", "max_forks_repo_head_hexsha": "37c98eccfa18a95acb1e98b276831641be92b38e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1663.0, "max_forks_repo_forks_event_min_datetime": "2015-12-17T17:45:38.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T07:58:29.000Z", "avg_line_length": 32.9711538462, "max_line_length": 95, "alphanum_fraction": 0.6899970837, "num_tokens": 891, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6757646010190476, "lm_q2_score": 0.5156199157230157, "lm_q1q2_score": 0.34843768662603863}} {"text": "#include \n#include \n#include \n#include \n\n/* A simple drag plugin. Usage:\n *\n * \n * \n * \n * 0 0 -0.2\n * -0.5, -0.4, 0\n * 10 20 30\n * 5 10 15\n * 4\n * 10\n * \n * \n * \n *\n * Drag force is applied to the center of mass.\n * Relative position of tether attachment.\n * Linear drag constants. See default calculation.\n * Angular drag constants. See defaut calculation.\n * Tether drag constant. See default calculation.\n * How far above z=0 the surface of the water is; used to calculate depth.\n *\n * Limitations:\n * Tether drag is modeled only in x\n */\n\nnamespace gazebo {\n\n/* drag = 0.5 * density * area * velocity^2 * coefficient\n *\n * The drag coefficient for a box is 1.0, so we'll use 0.9 for the ROV.\n * The drag coefficient for an unfaired tether is 1.2.\n *\n * The ROV constants below capture all but velocity:\n * constant = 0.5 * density * area * coefficient\n *\n * The tether constant below captures all but depth and velocity:\n * constant = 0.5 * density * width * coefficient\n */\n\nconstexpr double FLUID_DENSITY = 1029; // Fluid density of seawater\nconstexpr double ROV_DIM_X = 0.457; // Length\nconstexpr double ROV_DIM_Y = 0.338; // Width\nconstexpr double ROV_DIM_Z = 0.254; // Height\nconstexpr double ROV_AREA_X = ROV_DIM_Y * ROV_DIM_Z; // Fore, aft area\nconstexpr double ROV_AREA_Y = ROV_DIM_X * ROV_DIM_Z; // Top, bottom area\nconstexpr double ROV_AREA_Z = ROV_DIM_X * ROV_DIM_Y; // Port, starboard area\nconstexpr double ROV_DRAG_COEFFICIENT_X = 0.8;\nconstexpr double ROV_DRAG_COEFFICIENT_Y = 0.95;\nconstexpr double ROV_DRAG_COEFFICIENT_Z = 0.95;\nconstexpr double ROV_LINEAR_DRAG_X = 0.5 * FLUID_DENSITY * ROV_AREA_X * ROV_DRAG_COEFFICIENT_X;\nconstexpr double ROV_LINEAR_DRAG_Y = 0.5 * FLUID_DENSITY * ROV_AREA_Y * ROV_DRAG_COEFFICIENT_Y;\nconstexpr double ROV_LINEAR_DRAG_Z = 0.5 * FLUID_DENSITY * ROV_AREA_Z * ROV_DRAG_COEFFICIENT_Z;\nconstexpr double ANGULAR_DRAG_X = ROV_LINEAR_DRAG_X / 2; // A hack\nconstexpr double ANGULAR_DRAG_Y = ROV_LINEAR_DRAG_Y / 2;\nconstexpr double ANGULAR_DRAG_Z = ROV_LINEAR_DRAG_Z / 2; // TODO these are wrong, see revised cals in orca_mission.cpp\nconstexpr double TETHER_DIAM = 0.008;\nconstexpr double TETHER_DRAG_COEFFICIENT = 1.1;\nconstexpr double TETHER_DRAG = 0.5 * FLUID_DENSITY * TETHER_DIAM * TETHER_DRAG_COEFFICIENT;\n\nclass OrcaDragPlugin : public ModelPlugin\n{\nprivate:\n\n physics::LinkPtr base_link_;\n\n // Drag force will be applied to the center_of_mass_ (body frame)\n ignition::math::Vector3d center_of_mass_ {0, 0, 0};\n\n // Tether drag will be applied to the tether attachment point (body frame)\n ignition::math::Vector3d tether_attach_ {0, 0, 0};\n\n // Drag constants (body frame)\n ignition::math::Vector3d linear_drag_ {ROV_LINEAR_DRAG_X, ROV_LINEAR_DRAG_Y, ROV_LINEAR_DRAG_Z};\n ignition::math::Vector3d angular_drag_ {ANGULAR_DRAG_X, ANGULAR_DRAG_Y, ANGULAR_DRAG_Z};\n double tether_drag_ {TETHER_DRAG};\n\n // Distance to surface\n double surface_ {10};\n\n event::ConnectionPtr update_connection_;\n\npublic:\n\n // Called once when the plugin is loaded.\n void Load(physics::ModelPtr model, sdf::ElementPtr sdf)\n {\n std::string link_name {\"base_link\"};\n\n std::cout << std::endl;\n std::cout << \"ORCA DRAG PLUGIN PARAMETERS\" << std::endl;\n std::cout << \"-----------------------------------------\" << std::endl;\n std::cout << \"Default link name: \" << link_name << std::endl;\n std::cout << \"Default center of mass: \" << center_of_mass_ << std::endl;\n std::cout << \"Default tether attachment point: \" << tether_attach_ << std::endl;\n std::cout << \"Default linear drag: \" << linear_drag_ << std::endl;\n std::cout << \"Default angular drag: \" << angular_drag_ << std::endl;\n std::cout << \"Default tether drag: \" << tether_drag_ << std::endl;\n std::cout << \"Default surface: \" << surface_ << std::endl;\n\n GZ_ASSERT(model != nullptr, \"Model is null\");\n GZ_ASSERT(sdf != nullptr, \"SDF is null\");\n\n if (sdf->HasElement(\"link\"))\n {\n sdf::ElementPtr linkElem = sdf->GetElement(\"link\"); // Only one link is supported\n\n if (linkElem->HasAttribute(\"name\"))\n {\n linkElem->GetAttribute(\"name\")->Get(link_name);\n std::cout << \"Link name: \" << link_name << std::endl;\n }\n\n if (linkElem->HasElement(\"center_of_mass\"))\n {\n center_of_mass_ = linkElem->GetElement(\"center_of_mass\")->Get();\n std::cout << \"Center of mass: \" << center_of_mass_ << std::endl;\n }\n\n if (linkElem->HasElement(\"tether_attach\"))\n {\n tether_attach_ = linkElem->GetElement(\"tether_attach\")->Get();\n std::cout << \"Tether attachment point: \" << tether_attach_ << std::endl;\n }\n\n if (linkElem->HasElement(\"linear_drag\"))\n {\n linear_drag_ = linkElem->GetElement(\"linear_drag\")->Get();\n std::cout << \"Linear drag: \" << linear_drag_ << std::endl;\n }\n\n if (linkElem->HasElement(\"angular_drag\"))\n {\n angular_drag_ = linkElem->GetElement(\"angular_drag\")->Get();\n std::cout << \"Angular drag: \" << angular_drag_ << std::endl;\n }\n\n if (linkElem->HasElement(\"tether_drag\")) // TODO should be child of gazebo element, not link element\n {\n tether_drag_ = linkElem->GetElement(\"tether_drag\")->Get();\n std::cout << \"Tether drag: \" << tether_drag_ << std::endl;\n }\n\n if (linkElem->HasElement(\"surface\")) // TODO should be child of gazebo element, not link element\n {\n surface_ = linkElem->GetElement(\"surface\")->Get();\n std::cout << \"Surface: \" << surface_ << std::endl;\n }\n }\n\n base_link_ = model->GetLink(link_name);\n GZ_ASSERT(base_link_ != nullptr, \"Missing link\");\n\n // Listen for the update event. This event is broadcast every simulation iteration.\n update_connection_ = event::Events::ConnectWorldUpdateBegin(boost::bind(&OrcaDragPlugin::OnUpdate, this, _1));\n\n std::cout << \"-----------------------------------------\" << std::endl;\n std::cout << std::endl;\n }\n\n // Called by the world update start event, up to 1000 times per second.\n void OnUpdate(const common::UpdateInfo& /*info*/)\n {\n ignition::math::Vector3d linear_velocity = base_link_->RelativeLinearVel();\n ignition::math::Vector3d angular_velocity = base_link_->RelativeAngularVel();\n\n ignition::math::Vector3d drag_force;\n drag_force.X() = linear_velocity.X() * fabs(linear_velocity.X()) * -linear_drag_.X();\n drag_force.Y() = linear_velocity.Y() * fabs(linear_velocity.Y()) * -linear_drag_.Y();\n drag_force.Z() = linear_velocity.Z() * fabs(linear_velocity.Z()) * -linear_drag_.Z();\n base_link_->AddLinkForce(drag_force, center_of_mass_);\n\n ignition::math::Vector3d drag_torque;\n drag_torque.X() = angular_velocity.X() * fabs(angular_velocity.X()) * -angular_drag_.X();\n drag_torque.Y() = angular_velocity.Y() * fabs(angular_velocity.Y()) * -angular_drag_.Y();\n drag_torque.Z() = angular_velocity.Z() * fabs(angular_velocity.Z()) * -angular_drag_.Z();\n base_link_->AddRelativeTorque(drag_torque); // ODE adds torque at the center of mass\n\n // Tether drag only accounts for motion in x (forward/reverse)\n ignition::math::Vector3d tether_force;\n double depth = surface_ - base_link_->WorldPose().Pos().Z();\n tether_force.X() = linear_velocity.X() * fabs(linear_velocity.X()) * depth * -tether_drag_;\n tether_force.Y() = 0;\n tether_force.Z() = 0;\n base_link_->AddLinkForce(tether_force, tether_attach_);\n }\n};\n\nGZ_REGISTER_MODEL_PLUGIN(OrcaDragPlugin)\n\n}\n", "meta": {"hexsha": "3491f0f00b89566eaf7b0970b98dccdfc8e2aaa5", "size": 8148, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "orca_gazebo/src/drag_plugin.cpp", "max_stars_repo_name": "clydemcqueen/orca", "max_stars_repo_head_hexsha": "364a4771383360df609ebe93cf8c8aedac9f5844", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 29.0, "max_stars_repo_stars_event_min_datetime": "2017-10-04T14:25:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-19T10:40:02.000Z", "max_issues_repo_path": "orca_gazebo/src/drag_plugin.cpp", "max_issues_repo_name": "clydemcqueen/orca", "max_issues_repo_head_hexsha": "364a4771383360df609ebe93cf8c8aedac9f5844", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4.0, "max_issues_repo_issues_event_min_datetime": "2017-11-07T21:24:33.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-20T15:53:25.000Z", "max_forks_repo_path": "orca_gazebo/src/drag_plugin.cpp", "max_forks_repo_name": "clydemcqueen/orca", "max_forks_repo_head_hexsha": "364a4771383360df609ebe93cf8c8aedac9f5844", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2017-10-04T14:25:42.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-10T11:16:32.000Z", "avg_line_length": 41.3604060914, "max_line_length": 118, "alphanum_fraction": 0.6709621993, "num_tokens": 2255, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6757645879592642, "lm_q2_score": 0.5156199157230157, "lm_q1q2_score": 0.34843767989215424}} {"text": "#ifndef CANNON_PHYSICS_LAGRANGIAN_MECHANICS\n#define CANNON_PHYSICS_LAGRANGIAN_MECHANICS \n\n/*!\n * \\file cannon/physics/lagrangian_mechanics.hpp\n * \\brief File containing class and free function definitions for working with\n * Lagrangian dynamics, as in Structure and Interpretation of Classical\n * Mechanics.\n */\n\n#include \n\n#include \n\n#include \n\nusing namespace Eigen;\n\nusing namespace cannon::log;\n\nnamespace cannon {\n namespace physics {\n\n /*!\n * \\brief Struct representing a local tuple consisting of a coordinate\n * vector, velocity vector, and time. \n */\n struct LocalTuple {\n\n LocalTuple() = delete;\n\n /*!\n * \\brief Constructor taking generalized coordinate dimension and\n * initializing coordinates and time to zero.\n */\n LocalTuple(unsigned int dim) : dim(dim), time(0.0) {\n coordinates = VectorXd::Zero(dim);\n velocities = VectorXd::Zero(dim);\n }\n\n /*!\n * \\brief Copy constructor.\n */\n LocalTuple(const LocalTuple &l) : dim(l.dim), time(l.time),\n coordinates(l.coordinates), velocities(l.velocities) {}\n\n /*!\n * \\brief Move constructor.\n */\n LocalTuple(LocalTuple &&l) : dim(l.dim), time(l.time),\n coordinates(std::move(l.coordinates)),\n velocities(std::move(l.velocities)) {}\n\n /*!\n * \\brief Copy assignment operator.\n */\n LocalTuple& operator=(const LocalTuple& o) {\n dim = o.dim;\n time = o.time;\n coordinates = o.coordinates;\n velocities = o.velocities; \n\n return *this;\n }\n\n /*!\n * \\brief Get a vector representation of this local tuple.\n *\n * \\returns A vector containing the time, generalized coordinates, and\n * generalized velocity for this local tuple, in that order.\n */\n VectorXd to_vec();\n\n /*!\n * \\brief Initialize this local tuple with the input vector, which should\n * have the time, generalized coordinates, and generalized velocities, in\n * that order.\n *\n * \\param vec The vector to use for initialization.\n */\n void from_vec(const VectorXd& vec);\n\n unsigned int dim; //!< Dimension of generalized coordinates\n double time; //!< Time for this local tuple\n VectorXd coordinates; //!< Generalized coordinates for this local tuple.\n VectorXd velocities; //!< Generalized velocities for this local tuple\n\n };\n\n /*!\n * \\brief Struct representing a path as a series of waypoints in\n * generalized coordinates for doing Lagrangian mechanics.\n */\n struct Path {\n Path() = delete;\n\n /*!\n * \\brief Straight-line constructor taking a start, and end time and\n * start and end coordinates, as well as the number of waypoints to\n * construct.\n */\n Path(double t0, double t1, VectorXd start, VectorXd end, \n unsigned int length) : t0(t0), t1(t1) {\n assert(0 <= t0);\n assert(t0 < t1);\n assert(start.size() == end.size());\n assert(length >= 2);\n\n VectorXd delta = (end - start) / (double)(length-1);\n \n for (unsigned int i = 0; i < length; i++) {\n waypoints.push_back(start + i * delta); \n }\n }\n\n /*!\n * \\brief Constructor taking generalized coordinate dimension and a\n * vector of appended waypoints.\n */\n Path(unsigned int dim, const VectorXd& vec) {\n from_vec(dim, vec);\n }\n\n /*!\n * \\brief Get a vector representation of this path by appending all\n * waypoints.\n *\n * \\returns The vector representation.\n */\n VectorXd to_vec();\n\n /*!\n * \\brief Load a path with waypoints of the input dimension from the\n * input vector.\n *\n * \\param vec The vector to load.\n */\n void from_vec(unsigned int dim, const VectorXd& vec);\n\n /*!\n * \\brief Get the local tuple at time t from this path. \n *\n * Just doing linear interpolation for now.\n *\n * \\param t The time to get local tuple for.\n *\n * \\returns Local tuple at the input time along this path.\n */\n LocalTuple get_local_tuple(double t) const;\n\n double t0; //!< Start time for this path\n double t1; //!< End time for this path\n std::vector waypoints; //!< Waypoints making up this path\n };\n\n using Lagrangian = std::function;\n\n /*!\n * \\brief Compute path action of the input Lagrangian on the input path.\n *\n * \\param L The Lagrangian to use\n * \\param q The path to evaluate path action on\n * \n * \\returns The path action\n */\n double compute_path_action(Lagrangian L, const Path& q);\n\n } // namespace physics\n} // namespace cannon\n\n#endif /* ifndef CANNON_PHYSICS_LAGRANGIAN_MECHANICS */\n", "meta": {"hexsha": "722d7ecfbba03cdf1f0b625238969324688b74bc", "size": 4902, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "cannon/physics/lagrangian_mechanics.hpp", "max_stars_repo_name": "cannontwo/cannon", "max_stars_repo_head_hexsha": "4be79f3a6200d1a3cd26c28c8f2250dbdf08f267", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cannon/physics/lagrangian_mechanics.hpp", "max_issues_repo_name": "cannontwo/cannon", "max_issues_repo_head_hexsha": "4be79f3a6200d1a3cd26c28c8f2250dbdf08f267", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 46.0, "max_issues_repo_issues_event_min_datetime": "2021-01-12T23:03:52.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-01T17:29:01.000Z", "max_forks_repo_path": "cannon/physics/lagrangian_mechanics.hpp", "max_forks_repo_name": "cannontwo/cannon", "max_forks_repo_head_hexsha": "4be79f3a6200d1a3cd26c28c8f2250dbdf08f267", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.5, "max_line_length": 79, "alphanum_fraction": 0.6087311302, "num_tokens": 1099, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5698526514141571, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.34839763850849137}} {"text": "/*\n * H.cpp\n *\n * Created on: Apr 11, 2014\n * Author: wilfeli\n *\n *\n *\n *\n *\n *\n *\n *\n *\n */\n\n\n#include \n#include \n\n#include \"H.h\"\n#include \"Asset.h\"\n#include \"W.h\"\n#include \"Contract.h\"\n#include \"Market.h\"\n#include \"Tools.h\"\n\n\nusing Eigen::MatrixXd;\n\n\n\nH::H(W &w_, int id_):w(w_),\nl_ask(0.0, 0.0),\nc_bid(0.0, 0.0),\nid(id_),\ntheta_x(1,3),\ns0(1,18){\n\t// create reference to the world\n\tw.AddH(this);\n \n\t//create storage for goods\n\tass_asGC.push_back(new GoodC(this, 0.0));\n \n\t//create HK\n\tass_asHK.push_back(new HK(1.0));\n \n \n\ttype = \"H\";\n \n\tc_bid.issuer = this;\n\tl_ask.issuer = this;\n \n\t//create wm\n\tExpectationBackward* exp = new ExpectationBackward(1.0, 10, 0.5);\n\twm[\"MasCHK\"] = exp;\n \n\t//create wm\n\texp = new ExpectationBackward(1.0, 10, 0.5);\n\twm[\"MasGC\"] = exp;\n \n\t//create wm\n\texp = new ExpectationBackward(1.0, 0, 0.0);\n\twm[\"api\"] = exp;\n \n \n\t//create wm\n\texp = new ExpectationBackward(0.0, 0, 0.01);\n\twm[\"fi_ti\"] = exp;\n \n\t//parameters\n\tparam = new Parameters();\n\tparam->init();\n \n\t//accounting\n\taccount = new AccountH();\n \n \n};\n\nvoid\nH::init(){\n //ADP setup\n theta_V = Eigen::MatrixXd::Constant(1, 1, param->ADP_BF_N);\n B_n_1_RLS = Eigen::MatrixXd::Zero(param->ADP_BF_N, param->ADP_BF_N);\n \n //QL setup\n _set_QL();\n \n \n //mRe setup\n _set_mRE();\n\n \n};\n\nvoid\nH::ac_W(MessageMakeDec* mes){\n \n\t//calls opt choice\n\t_s0();\n\t//calls opt choice\n if (param->opt_TYPE == \"EO_CS\"){\n opt_CS(&s0,&theta_x, param->opt_CS_N);\n };\n \n if (param->opt_TYPE == \"EO_ADP\"){\n theta_V = _API_LM(&s0, param->ADP_API_LM_N, param->ADP_API_LM_M);\n\n Eigen::Block s = s0.block(0,0,s0.rows(),s0.cols());\n _opt_CS_s_V(s,theta_x, theta_V, param->opt_CS_N);\n };\n \n if (param->opt_TYPE == \"QL\"){\n opt_QL();\n };\n \n if (param->opt_TYPE == \"mRE\"){\n opt_mRE();\n \n };\n \n \n\t//transforms it into ask and bid\n\tl_ask.q = theta_x(0,0) * s0(0,1);\n\tl_ask.p = theta_x(0,1) * s0(0,4);\n \n\tc_bid.pq_share = theta_x(0,2);\n \n \n \n};\n\n\nAsk*\nH::ac_L(){\n\t//update numbers in bid\n\tl_ask.supply_curve = Eigen::MatrixXd::Zero(1,2);\n\tl_ask.supply_curve << l_ask.p , l_ask.q;\n \n\tl_ask.p_t_0 = l_ask.p;\n\tl_ask.q_t_0 = l_ask.q;\n \n \n \n\t//return reference to the ask\n\treturn &l_ask;\n};\n\nBid*\nH::ac_C(){\n\t//update numbers in bid\n\tc_bid.pq = _s0()(0,0) * c_bid.pq_share;\n \n\tc_bid.pq_t_0 = c_bid.pq;\n\tc_bid.pq_share_t_0 = c_bid.pq_share;\n \n \n\t//update numbers in bid\n \n \n// if (param->GRID == \"test\"){\n// c_bid.demand_curve = Eigen::MatrixXd::Zero(1,2);\n// c_bid.demand_curve.row(0) << wm[\"MasGC\"]->mu , c_bid.pq/wm[\"MasGC\"]->mu ;\n// return &c_bid;\n// };\n \n \n\t//number of steps\n\tint N_STEPS_dc = 30;\n\tdouble P_MAX_dc = wm[\"MasGC\"]->mu * 10;\n\tdouble P_MIN_dc = wm[\"MasGC\"]->mu * 0.01;\n\tdouble STEP_SIZE = (P_MAX_dc - P_MIN_dc)/N_STEPS_dc;\n \n\tc_bid.demand_curve = Eigen::MatrixXd::Zero(N_STEPS_dc,2);\n\tfor (int i = 0; i < N_STEPS_dc; i++){\n \n\t\tc_bid.demand_curve.row(i) << P_MIN_dc + i * STEP_SIZE, c_bid.pq/(P_MIN_dc + i * STEP_SIZE);\n \n\t};\n \n \n \n \n\t//return reference to the bid\n\treturn &c_bid;\n};\n\n\n\n\ndouble\nH::_mas_q_sell(MessageMarketLCheckAsk* inf){\n\t//checks how much to sell\n\t//return q from ask\n \n\tdouble q_sell;\n \n\tif (inf->p_eq >= l_ask.p){\n\t\tq_sell = l_ask.q;\n\t};\n \n\treturn q_sell;\n};\n\ndouble\nH::_mas_q_buy(MessageMarketCCheckBid* inf){\n\t//checks how much to sell\n\t//return q from ask\n \n \n\tdouble q_buy;\n \n\tint i=0;\n \n\twhile ((c_bid.demand_curve(i,0) < inf->p_eq) && (ibuyer,\n inf->p,\n inf->q,\n w.t,\n w.t);\n \n\ttype = \"H_EO\";\n \n\tass_asCHK.push_back(cHK);\n \n\t//?update ask\n\tl_ask.q -= cHK->q;\n \n\t//tell market about the contract\n\tinf->sender->_clear_C(cHK);\n \n\t//call accounting\n\t//create accounting message\n //\tMessageSellC* mes = new MessageSellC(inf, cHK);\n\taccount->ac_get_inf(inf, cHK);\n \n //\tdelete mes;\n \n \n};\n\ndouble\nH::_goal_t(Eigen::MatrixXd* s){\n \n\tdouble l;\n\tdouble c;\n \n\tif ((*s)(0,3) <= 0.0){\n\t\tc = -0.5;\n// c = 0.0;\n\t}else{\n c = (*s)(0,3);\n };\n \n\tl = (*s)(0,2);\n \n\treturn (param->GOAL_T_theta(0,0) * log(1+c) + param->GOAL_T_theta(0,1) * (1-l));\n// return (param->GOAL_T_theta(0,0) * log(0.5+c) + param->GOAL_T_theta(0,1) * (1-l));\n};\n\n\n\nvoid\nH::_buy_asGC(MessageGoodC* mes){\n \n\tass_asGC.back()->q += mes->q;\n\taccount->ac_get_inf(mes);\n \n};\n\n\nvoid\nH::_PS_receive_payment(MessagePSSendPayment* mes){\n \n\taccount->ac_get_inf(mes);\n \n};\n\n\nbool\nH::_PS_send_payment(MessagePSSendPayment* inf){\n \n\tinf->sender = this; //static_cast(const_cast(this));\n \n\tbool FLAG_CLEARED = ass_asCBDt0.front()->issuer->_PS_accept_PO(inf);\n \n \n \n\tif(FLAG_CLEARED){\n\t\taccount->ac_get_inf(inf);\n \n\t};\n \n\treturn FLAG_CLEARED;\n \n \n};\n\nvoid\nH::ac_W_begin_step(){\n \n\t//update accounting\n\taccount->ac_W_initialize_step();\n \n\t//\n\tfor (auto c:ass_asCHK){\n\t\tif (c->t_end <= w.t){\n\t\t\tdelete c;\n\t\t\tc = NULL;\n\t\t};\n\t};\n \n \n\t//clear contracts\n\tass_asCHK.erase(std::remove_if(ass_asCHK.begin(), ass_asCHK.end(),\n [&](ContractHK* x) -> bool { return (x); }),\n ass_asCHK.end());\n \n \n \n};\n\nvoid\nH::ac_W_begin_step(MessageStatus* mes){\n\tif (mes->status <= 0.0){\n\t\taccount->ac_W_initialize_step(mes);\n\t};\n};\n\nvoid\nH::ac_W_end_step(){\n\t//updates state\n\t_s0();\n\tdouble ut = _goal_t(&s0);\n\taccount->ac_W_end_step(&s0, ut);\n \n\t//eats good\n\tass_asGC.front()->q = 0.0;\n \n};\n\nvoid\nH::ac_W_end_step(MessageStatus* mes){\n if (mes->status <= 0.0){\n ac_W_end_step();\n };\n};\n\n\n\nvoid\nH::wm_update_k_s(){\n\tif (w.t > 0.0){\n \n\t\tMatrixXd w0 = wm_w0_tbeg();\n\t\tExpectationBackward* exp_i;\n\t\tstd::vector s_t_i;\n \n\t\t//update k_s if conditions are met\n//\t\tif ((w0(0,1) > 0.0) || ((w0(0,1) == 0.0) && (w0(0,0) != 0.0)) || ((w0(0,4) > 0.0) && (w0(0,0) == 0.0))){\n\t\t\ts_t_i.push_back(w0(0,0));\n\t\t\ts_t_i.push_back((w0(0,1) > 0.0)? w0(0,1):w0(0,7));\n \n\t\t\texp_i = wm[\"MasCHK\"];\n \n\t\t\texp_i->s_t.push_back(s_t_i);\n \n\t\t\twm_update_expectation_backward(exp_i, 1, true);\n//\t\t};\n \n\t\ts_t_i.clear();\n \n\t\ts_t_i.push_back(w0(0,2));\n\t\ts_t_i.push_back((w0(0,2) > 0.0)? w0(0,3)/w0(0,2):w0(0,8));\n \n \n\t\texp_i = wm[\"MasGC\"];\n \n\t\texp_i->s_t.push_back(s_t_i);\n \n\t\twm_update_expectation_backward(exp_i, 1, true);\n \n\t\ts_t_i.clear();\n \n \n\t\tif (w.t > 0.0){\n\t\t\texp_i = wm[\"api\"];\n \n\t\t\ts_t_i.push_back(w0(0,5));\n\t\t\texp_i->s_t.push_back(s_t_i);\n \n\t\t\twm_update_expectation_backward(exp_i, 0, false);\n \n \n\t\t\ts_t_i.clear();\n \n\t\t\texp_i = wm[\"fi_ti\"];\n \n\t\t\ts_t_i.push_back(w0(0,6));\n\t\t\texp_i->s_t.push_back(s_t_i);\n \n//\t\t\twm_update_expectation_backward(exp_i, 0, false);\n wm_update_expectation_backward(exp_i, 0, true);\n \n\t\t};\n \n \n if (param->opt_TYPE == \"QL\"){\n wm_update_Q();\n \n };\n \n if (param->opt_TYPE == \"mRE\"){\n wm_update_mRE();\n \n };\n \n \n\t};\n \n \n \n};\n\n\nvoid\nH::wm_update_expectation_backward(ExpectationBackward* exp_i, int p_position, bool FLAG_UPDATE_V){\n \n\tstd::vector p;\n \n\tint i_s_t_1_max = 0;\n\tlong i_s_t_max = 0;\n \n\t//depending on the length of the wm and accumulated number of prices\n\tif (std::isinf(param->WM_LENGTH)){\n\t\ti_s_t_1_max = exp_i->s_t_1[\"n\"];\n\t\ti_s_t_max = exp_i->s_t.size();\n\t}else{\n\t\ti_s_t_1_max = std::min(std::max(param->WM_LENGTH - exp_i->s_t.size(), 0.0), exp_i->s_t_1[\"n\"]);\n\t\ti_s_t_max = std::min(param->WM_LENGTH, (double)exp_i->s_t.size());\n\t};\n \n\tfor (int i = 0; i < i_s_t_1_max; i++){\n\t\tp.push_back(exp_i->s_t_1[\"mu\"]);\n\t};\n \n\t//push other prices\n\tfor (std::size_t i = (exp_i->s_t.size() - i_s_t_max);i < exp_i->s_t.size();i++){\n\t\tp.push_back(exp_i->s_t[i][p_position]);\n\t};\n \n\tMatrixXd mean_variance = wm_mean_variance(p);\n \n\texp_i->mu = mean_variance(0,0);\n\texp_i->n += 1.0;\n \n if (FLAG_UPDATE_V){\n exp_i->v = mean_variance(1,0);\n \n if (exp_i->v <= 0.0){\n exp_i->v = exp_i->mu * 0.01;\n };\n \n \n };\n \n \n \n};\n\n\n\nEigen::MatrixXd\nH::wm_mean_variance(std::vector &x){\n\tMatrixXd mean_variance(2,1);\n \n\t//gets mean and variance\n\tdouble sum = std::accumulate(x.begin(), x.end(), 0.0);\n\tdouble mean = sum / x.size();\n\tstd::vector diff(x.size());\n\tstd::transform(x.begin(), x.end(), diff.begin(),\n\t std::bind2nd(std::minus(), mean));\n\tdouble sq_sum = std::inner_product(diff.begin(), diff.end(), diff.begin(), 0.0);\n //\tdouble stdev = std::sqrt(sq_sum / x.size());\n\tdouble variance = sq_sum/x.size();\n \n\tmean_variance(0,0) = mean;\n\tmean_variance(1,0) = variance;\n \n\treturn mean_variance;\n};\n\n\nEigen::MatrixXd\nH::wm_w0_tbeg(){\n\tMatrixXd w0(1,9);\n \n\tlong life_length = account->asCHK_q.size();\n \n\tw0(0,0) = account->asCHK_q.at(life_length - 2);\n\tw0(0,1) = account->asCHK_p.at(life_length - 2);\n\tw0(0,2) = account->asGC_q.at(life_length - 2);\n\tw0(0,3) = account->asGC_pq.at(life_length - 2);\n \n\tw0(0,4) = l_ask.q_t_0;\n\tw0(0,5) = account->FI_div_t.at(life_length - 2) + account->asCHK_p_t.at(life_length - 2);\n\tw0(0,6) = account->FI_div_t.at(life_length - 2);\n \n\tw0(0,7) = w.ml->market_price.at(w.t - 1)->p;\n\tw0(0,8) = w.mc->market_price.at(w.t - 1)->p;\n \n //\tstd::cout << w0 << std::endl;\n \n \n \n\treturn w0;\n};\n\n\nEigen::MatrixXd\nH::_s0(){\n\t//money holdings\n\ts0(0,0) = ass_asCBDt0.front()->q;\n \n\ts0(0,1) = ass_asHK.front()->q;\n \n\ts0(0,2) = 0.0;\n\t//labor to be supplied\n\tfor (auto c:ass_asCHK){\n\t\ts0(0,2) += c->q;\n\t};\n \n \n\t//amount of good c\n\ts0(0,3) = ass_asGC.front()->q;\n \n\t//expected price on labor market\n\ts0(0,4) = wm[\"MasCHK\"]->mu;\n \n\t//number of observations\n\ts0(0,5) = wm[\"MasCHK\"]->n;\n \n\t//expected price on goods market\n\ts0(0,6) = wm[\"MasGC\"]->mu;\n \n\t//number of observations\n\ts0(0,7) = wm[\"MasGC\"]->n;\n \n \n \n \n\t//average past income\n\ts0(0,8) = wm[\"api\"]->mu;\n \n\ts0(0,9) = wm[\"api\"]->n;\n \n\t//current income\n\ts0(0,10) = account->FI_div_t.back() + account->asCHK_p_t.back();\n \n\t//to be used in max routinue\n\t//current signed labor contracts - q\n\ts0(0,11) = 0.0;\n \n\t//current signed labor contracts - p\n\ts0(0,12) = 0.0;\n \n\t//financial income\n\ts0(0,13) = wm[\"fi_ti\"]->mu;\n \n\ts0(0,14) = wm[\"fi_ti\"]->n;\n \n \n\t//variance of labor market\n\ts0(0,15) = wm[\"MasCHK\"]->v;\n \n\t//variance of goods market\n\ts0(0,16) = wm[\"MasGC\"]->v;\n \n\t//variance of financial income\n\ts0(0,17) = wm[\"fi_ti\"]->v;\n \n \n\t//\n \n \n\treturn s0;\n};\n\n\n\n\nvoid\nH::opt_CS(MatrixXd* s0, MatrixXd* theta_x, int N){\n \n//\tN = 1;\n \n\t//gets matrix of thetas\n\t//prepare initial matrix\n\tMatrixXd m_s0 = MatrixXd::Zero(N, s0->cols());\n \n\tm_s0.rowwise() += s0->row(0);\n \n \n\t//allocate space to the matrix\n\tMatrixXd n_w;\n\tMatrixXd n_x;\n\tMatrixXd n_s = MatrixXd::Zero(N, s0->cols());\n\tMatrixXd n_c;\n \n \n\t//create matrix for the grid - small size here\n\tMatrixXd grid(3,3);\n \n create_decision_grid(grid,0);\n\n \n \n if (w.param->SIMULATION_MODE == \"test\"){\n Tools::mgrid_test(grid, &theta_x_all);\n \n } else{\n \n Tools::mgrid(grid, &theta_x_all);\n };\n \n //\tstd::cout << theta_x_all.transpose() << \"\\n\";\n \n \n\t//create random number generators for the implementation\n \n\tboost::normal_distribution<> nd_w1((*s0)(0,4), pow((*s0)(0,15),0.5));\n\tboost::normal_distribution<> nd_w2((*s0)(0,6), pow((*s0)(0,16),0.5));\n\tboost::normal_distribution<> nd_w3((*s0)(0,13), pow((*s0)(0,17),0.5));\n \n\tboost::variate_generator> rng_w1(w.rng, nd_w1);\n \n\tboost::variate_generator> rng_w2(w.rng, nd_w2);\n \n\tboost::variate_generator> rng_w3(w.rng, nd_w3);\n \n\n \n if (w.param->SIMULATION_MODE != \"test\"){\n\n //draw random variables\n //fast realization\n n_w = MatrixXd::Zero(N, 3 * param->T_MAX);\n for (int i = 0; i < N; i++){\n for(int j=0; j< n_w.cols(); j++){\n if (j%3 == 0){\n n_w(i,j) = rng_w1();\n } else {\n if (j%3 == 1){\n n_w(i,j) = rng_w2();\n }else{\n n_w(i,j) = rng_w3();\n };\n \n };\n n_w(i,j) = std::max(0.0, (double)n_w(i,j));\n };\n };\n };\n \n\n \n \n \n \n \n\t//matrix of all\n\tMatrixXd c_all(theta_x_all.cols(),1);\n \n\tfor (int i = 0 ; i < theta_x_all.cols(); i++){\n if (w.param->SIMULATION_MODE == \"test\"){\n n_w = MatrixXd::Zero(N, 3 * param->T_MAX);\n for (int i = 0; i < N; i++){\n for(int j=0; j< n_w.cols(); j++){\n if (j%3 == 0){\n n_w(i,j) = Tools::get_normal((*s0)(0,4), pow((*s0)(0,15),0.5), w.myrng);\n } else {\n if (j%3 == 1){\n n_w(i,j) = Tools::get_normal((*s0)(0,6), pow((*s0)(0,16),0.5), w.myrng);\n }else{\n n_w(i,j) = Tools::get_normal((*s0)(0,13), pow((*s0)(0,17),0.5), w.myrng);\n };\n \n };\n n_w(i,j) = std::max(0.0, (double)n_w(i,j));\n };\n };\n };\n\n\t\t//call estimator of results of steps, given theta_x\n theta_x->row(0) = theta_x_all.col(i).transpose();\n\t\tn_x = MatrixXd::Zero(N, 3);\n\t\tn_s = m_s0;\n\t\tn_c = MatrixXd::Zero(N, param->T_MAX);\n\t\t_step_opt_CS(theta_x, &n_w, &n_x, &n_s, &n_c, param->T_MAX);\n \n\t\t//after n_c\n\t\t//average over n runs\n// std::cout << n_w << std::endl;\n// std::cout << n_c << std::endl;\n\t\tc_all(i,0) = (n_c * param->BETA_T).mean();\n \n\t};\n\n \n \n \n //\tstd::cout << c_all << \"\\n\";\n \n\t//find all max elements\n\tdouble max = c_all(0,0);\n\tstd::list i_max;\n\tfor (int i=0; i max){\n\t\t\t\tmax = c_all(i,0);\n\t\t\t\ti_max.clear();\n\t\t\t\ti_max.push_back(i);\n\t\t\t};\n\t\t}\n\t};\n \n\t//if more than 1 max - randomly pick\n\tlong theta_max_i;\n\tif (i_max.size()>1){\n\t\tboost::random::uniform_int_distribution<> i_max_dist(0, i_max.size()-1);\n\t\ttheta_max_i = i_max_dist(w.rng);\n\t}else{\n\t\ttheta_max_i = i_max.front();\n\t};\n \n \n\ttheta_x->row(0) = theta_x_all.col(theta_max_i).transpose();\n \n //\tstd::cout << \"theta\" << *theta_x << \"\\n\";\n};\n\n\ndouble\nH::get_status(){\n\treturn status;\n};\n\n\nvoid\nH::_step_opt_CS(MatrixXd *theta_x,\n MatrixXd *w,\n MatrixXd *x,\n MatrixXd *s,\n MatrixXd *c,\n int T){\n \n\tdouble l_t;\n\tdouble c_t;\n \n //\tstd::cout <<\"w\" << *w << \"\\n\";\n \n\tfor (int i=0; i< T; i++){\n \n\t\tx->col(0) = (*theta_x)(0,0) * s->col(1).array();\n\t\tx->col(1) = (*theta_x)(0,1) * s->col(4).array();\n \n\t\t//labor market results\n\t\t//if wage is less than realized wage - get hired, otherwise zero\n\t\ts->col(11) = (w->col(i*3).array() >= x->col(1).array()).cast().array() *x->col(0).array();\n\t\ts->col(12) = w->col(i*3);\n \n //\t\tauto FLAG_UPDATE = ((s->col(12) > 0.0).array() ||\n //\t\t\t\t\t\t\t((s->col(12) == 0.0).array() &&\n //\t\t\t\t\t\t\t(s->col(11) != 0.0).array()) ||\n //\t\t\t\t\t\t\t((x->col(0) > 0.0).array() &&\n //\t\t\t\t\t\t\t(s->col(11) == 0.0).array()));\n \n\t\t//TODO update inside , not coded for now\n //\t\tif (param->wm_INSIDE_UPDATE){\n //\t\t};\n \n\t\t//made consumption good decision\n\t\tx->col(2) = (*theta_x)(0,2) * s->col(0).array();\n \n \n\t\t//buy consumption goods , assume all goods are consumed in the previous\n\t\t//period, so no addition here\n\t\tfor (int j=0; jrows(); j++){\n\t\t\tif ((*w)(j,i*3 + 1) > 0.0){\n\t\t\t\t(*s)(j,3) = (*x)(j,2) / (*w)(j,i*3 + 1);\n \n \n \n\t\t\t\t//for speed calculate goal in this cycle\n\t\t\t\t//stores realization of a goal\n\t\t\t\t//as couldn't pass block need to calculate in place?\n \n //\t\t\t\t(*c)(j,i) = _goal_t(&(s->block(1,s->cols(),j,0)));\n\t\t\t}else{\n\t\t\t\t(*s)(j,3) = 0.0;\n\t\t\t};\n \n\t\t\tif ((*s)(j,3) <= 0.0){\n\t\t\t\tc_t = -0.5;\n// c_t = 0.0;\n\t\t\t} else {\n\t\t\t\tc_t = (*s)(j,3);\n\t\t\t};\n \n\t\t\tl_t = (*s)(j,11);\n \n \n\t\t\t(*c)(j,i) = param->GOAL_T_theta(0,0) * log(1+c_t) + param->GOAL_T_theta(0,1) * (1-l_t);\n// (*c)(j,i) = param->GOAL_T_theta(0,0) * log(0.5+c_t) + param->GOAL_T_theta(0,1) * (1-l_t);\n\n \n\t\t};\n \n\t\t//account for money being spent\n\t\ts->col(0) = s->col(0).array() - w->col(i*3 + 1).array() * s->col(3).array();\n \n \n\t\t//labor payments\n\t\ts->col(0) = s->col(0).array() + s->col(11).array() * s->col(12).array();\n \n\t\t//dividend payment\n\t\ts->col(0) += w->col(i*3 + 2);\n \n //\t\tstd::cout << s->col(0) << \"\\n\";\n// std::cout << *s << \"\\n\";\n //\t\tstd::cout << *c << \"\\n\";\n //\t\tstd::cout << *x << \"\\n\";\n \n\t\t//skipped, because they are assigned, not added in a cycle\n\t\t//zero labor contracts\n\t\t//zero consumption good\n \n\t};\n \n};\n\n\n \n \nvoid\nH::_bf(Eigen::MatrixXd* s, Eigen::MatrixXd* ret){\n (*ret)(0,0) = (*s)(0,0);\n};\n\nvoid\nH::_bf(Eigen::Block& s, Eigen::MatrixXd* ret){\n (*ret)(0,0) = s(0,0);\n};\n\n\ndouble\nH::_V(Eigen::MatrixXd* s, Eigen::MatrixXd* phi_f, Eigen::MatrixXd& theta_V){\n _bf(s, phi_f);\n \n return (theta_V*(*phi_f).transpose()).sum();\n \n};\n\n\ndouble\nH::_V(Eigen::Block& s, Eigen::MatrixXd* phi_f, Eigen::MatrixXd& theta_V){\n _bf(s, phi_f);\n \n return (theta_V*(*phi_f).transpose()).sum();\n \n};\n\nEigen::MatrixXd\nH::_API_LM(Eigen::MatrixXd* s0, int N, int M){\n //Approximate policy iteration using linear models.\n //\n //p.407 ADP\n //\n \n //fix basis functions\n long n_theta_t = param->ADP_BF_N;\n \n //inner theta\n //theta for now and future\n Eigen::MatrixXd theta_V_n = Eigen::MatrixXd::Constant(1, n_theta_t, 1);\n \n //policy theta\n Eigen::MatrixXd theta_V_pi = theta_V;\n \n \n Eigen::MatrixXd s_n_m;\n Eigen::MatrixXd v_n_m;\n Eigen::MatrixXd x_n_m(1,3);\n Eigen::MatrixXd phi(1, param->ADP_BF_N);\n Eigen::MatrixXd phi1(1, param->ADP_BF_N);\n \n \n \n for (int n=0; ncols());\n s_n_m.row(0) += s0->row(0);\n //v_n_m_T1 = 0\n v_n_m = Eigen::MatrixXd::Constant(M, n_theta_t, 0.0);\n \n \n for (int m=0; m s = s_n_m.block(m,0,1,(*s0).cols());\n \n \n //choose action, takes reference to s\n _opt_CS_s_V(s, x_n_m, theta_V_pi, param->opt_CS_N);\n \n s_n_m.block(m+1,0,1,(*s0).cols()) = s;\n \n Eigen::Block s1 = s_n_m.block(m+1,0,1,(*s0).cols());\n s = s_n_m.block(m,0,1,(*s0).cols());\n \n \n //make step given action, to update state and return value function\n double _c = _c_theta_x(x_n_m, s1, theta_V_pi);\n \n double c_n_m = _c - _V(s1,&phi,theta_V_pi);\n \n _bf(s,&phi);\n _bf(s1,&phi1);\n Eigen::MatrixXd v_n_m = phi - param->BETA*phi1;\n \n // std::cout << s_n_m.row(m) << std::endl;\n // std::cout << s << std::endl;\n //\n // std::cout << s_n_m.row(m+1) << std::endl;\n // std::cout << theta_V_pi << std::endl;\n // std::cout << theta_V_n << std::endl;\n \n \n //update theta_V_n\n theta_V_n = _RLS(theta_V_n,\n v_n_m,\n s,\n m,\n c_n_m);\n //assume that only 1 element in v and restrict it\n if (theta_V_n(0,0) > 1000){\n theta_V_n(0,0) = 1000;\n };\n if (theta_V_n(0,0) < 0.0){\n theta_V_n(0,0) = 0.01;\n };\n \n };\n \n theta_V_pi = theta_V_n;\n };\n \n //std::cout << theta_V_pi << std::endl;\n return theta_V_pi;\n};\n\nEigen::MatrixXd\nH::_RLS(Eigen::MatrixXd& theta, Eigen::MatrixXd& v, Eigen::Block& s, int i, double c){\n \n //i - iteration if i = 0 - initialize B\n //for each theta_t:\n Eigen::MatrixXd B_n_1;\n \n if (i == 0){\n //identity matrix\n double e_B_0 = 0.0005;\n \n //B(n-1)\n B_n_1 = e_B_0 * Eigen::MatrixXd::Identity(param->ADP_BF_N, param->ADP_BF_N);\n \n }else{\n B_n_1 = B_n_1_RLS;\n };\n \n //container for basis functions\n Eigen::MatrixXd phi(1, param->ADP_BF_N);\n _bf(s,&phi);\n \n double e_n = c - (v.transpose()*theta)(0,0);\n \n double gamma_n = 1 + ((v.transpose()*B_n_1)*phi)(0,0);\n \n \n Eigen::MatrixXd B_n = B_n_1 - 1/gamma_n *((B_n_1*(phi*v.transpose()))*B_n_1);\n \n Eigen::MatrixXd theta_n = theta + 1/gamma_n * ((e_n*B_n_1)*phi);\n \n // std::cout << 1/gamma_n * ((e_n*B_n_1)*phi) << std::endl;\n \n // std::cout << theta_n << std::endl;\n \n B_n_1_RLS = B_n;\n \n \n \n return theta_n;\n \n \n};\n\n\n\n\nvoid\nH::_opt_CS_s_V(Eigen::Block& s0, Eigen::MatrixXd& theta_x, Eigen::MatrixXd& theta_V, int N){\n \n //\tN = 1;\n \n\t//gets matrix of thetas\n\t//prepare initial matrix\n\tMatrixXd m_s0 = MatrixXd::Zero(N, s0.cols());\n \n\tm_s0.rowwise() += s0.row(0);\n \n \n\t//allocate space to the matrix\n\tMatrixXd n_w;\n\tMatrixXd n_x;\n\tMatrixXd n_s = MatrixXd::Zero(N, s0.cols());\n\tMatrixXd n_c;\n MatrixXd v_bf_ret = MatrixXd::Zero(1, param->ADP_BF_N);\n MatrixXd n_v;\n \n \n\t//create matrix for the grid - small size here\n\tMatrixXd grid(3,3);\n \n create_decision_grid(grid,0);\n \n if (w.param->SIMULATION_MODE == \"test\"){\n Tools::mgrid_test(grid, &theta_x_all);\n \n } else{\n \n Tools::mgrid(grid, &theta_x_all);\n };\n \n\t//create random number generators for the implementation\n \n\tboost::normal_distribution<> nd_w1(s0(0,4), pow(s0(0,15),0.5));\n\tboost::normal_distribution<> nd_w2(s0(0,6), pow(s0(0,16),0.5));\n\tboost::normal_distribution<> nd_w3(s0(0,13), pow(s0(0,17),0.5));\n \n\tboost::variate_generator> rng_w1(w.rng, nd_w1);\n \n\tboost::variate_generator> rng_w2(w.rng, nd_w2);\n \n\tboost::variate_generator> rng_w3(w.rng, nd_w3);\n \n \n \n if (w.param->SIMULATION_MODE != \"test\"){\n \n //draw random variables\n //fast realization\n n_w = MatrixXd::Zero(N, 3 * param->T_MAX);\n for (int i = 0; i < N; i++){\n for(int j=0; j< n_w.cols(); j++){\n if (j%3 == 0){\n n_w(i,j) = rng_w1();\n } else {\n if (j%3 == 1){\n n_w(i,j) = rng_w2();\n }else{\n n_w(i,j) = rng_w3();\n };\n \n };\n n_w(i,j) = std::max(0.0, (double)n_w(i,j));\n };\n };\n };\n \n\t//matrix of all\n\tMatrixXd c_all(theta_x_all.cols(),1);\n \n\tfor (int i = 0 ; i < theta_x_all.cols(); i++){\n if (w.param->SIMULATION_MODE == \"test\"){\n n_w = MatrixXd::Zero(N, 3 * param->T_MAX);\n for (int i = 0; i < N; i++){\n for(int j=0; j< n_w.cols(); j++){\n if (j%3 == 0){\n n_w(i,j) = Tools::get_normal(s0(0,4), pow(s0(0,15),0.5), w.myrng);\n } else {\n if (j%3 == 1){\n n_w(i,j) = Tools::get_normal(s0(0,6), pow(s0(0,16),0.5), w.myrng);\n }else{\n n_w(i,j) = Tools::get_normal(s0(0,13), pow(s0(0,17),0.5), w.myrng);\n };\n \n };\n n_w(i,j) = std::max(0.0, (double)n_w(i,j));\n };\n };\n };\n \n\t\t//call estimator of results of steps, given theta_x\n\t\ttheta_x.row(0) = theta_x_all.col(i).transpose();\n\t\tn_x = MatrixXd::Zero(N, 3);\n\t\tn_s = m_s0;\n\t\tn_c = MatrixXd::Zero(N, 1);\n n_v = MatrixXd::Zero(N, 1);\n\t\t_step_opt_CS(theta_x, &n_w, &n_x, &n_s, &n_c, &n_v, theta_V, &v_bf_ret, 1);\n \n\t\t//after n_c\n\t\t//average over n runs\n c_all(i,0) = (n_c + param->BETA*n_v).mean();\n \n\t};\n \n // std::cout << (n_c + param->BETA*n_v).mean() << std::endl;\n \n \n\t//find all max elements\n\tdouble max = c_all(0,0);\n\tstd::list i_max;\n\tfor (int i=0; i max){\n\t\t\t\tmax = c_all(i,0);\n\t\t\t\ti_max.clear();\n\t\t\t\ti_max.push_back(i);\n\t\t\t};\n\t\t}\n\t};\n \n\t//if more than 1 max - randomly pick\n\tlong theta_max_i;\n\tif (i_max.size()>1){\n\t\tboost::random::uniform_int_distribution<> i_max_dist(0, i_max.size()-1);\n\t\ttheta_max_i = i_max_dist(w.rng);\n\t}else{\n\t\ttheta_max_i = i_max.front();\n\t};\n \n \n\ttheta_x.row(0) = theta_x_all.col(theta_max_i).transpose();\n \n // std::cout << theta_x << std::endl;\n};\n\nvoid\nH::_step_opt_CS(MatrixXd& theta_x,\n MatrixXd *w,\n MatrixXd *x,\n MatrixXd *s,\n MatrixXd *c,\n MatrixXd* v,\n MatrixXd& theta_v,\n MatrixXd* ret,\n int T){\n \n\tdouble l_t;\n\tdouble c_t;\n\n\t//zero vector\n\tauto s_zero = MatrixXd::Zero(s->rows(),1);\n Eigen::Block s_block = s->block(0,0,1,s->cols());;\n\n \n \n //\tstd::cout <<\"w\" << *w << \"\\n\";\n \n\tfor (int i=0; i< T; i++){\n \n\t\tx->col(0) = theta_x(0,0) * s->col(1).array();\n\t\tx->col(1) = theta_x(0,1) * s->col(4).array();\n \n\t\t//labor market results\n\t\t//if wage is less than realized wage - get hired, otherwise zero\n\t\ts->col(11) = (w->col(i*3).array() >= x->col(1).array()).cast().array() *x->col(0).array();\n\t\ts->col(12) = w->col(i*3);\n \n\t\t//made consumption good decision\n\t\tx->col(2) = theta_x(0,2) * s->col(0).array();\n \n \n\t\t//buy consumption goods , assume all goods are consumed in the previous\n\t\t//period, so no addition here\n\t\tfor (int j=0; jrows(); j++){\n\t\t\tif ((*w)(j,i*3 + 1) > 0.0){\n\t\t\t\t(*s)(j,3) = (*x)(j,2) / (*w)(j,i*3 + 1);\n \n \n \n\t\t\t\t//for speed calculate goal in this cycle\n\t\t\t\t//stores realization of a goal\n\t\t\t\t//as couldn't pass block need to calculate in place?\n \n //\t\t\t\t(*c)(j,i) = _goal_t(&(s->block(1,s->cols(),j,0)));\n\t\t\t}else{\n\t\t\t\t(*s)(j,3) = 0.0;\n\t\t\t};\n \n\t\t\tif ((*s)(j,3) <= 0.0){\n\t\t\t\tc_t = -0.5;\n// c_t = 0.0;\n\t\t\t} else {\n\t\t\t\tc_t = (*s)(j,3);\n\t\t\t};\n \n\t\t\tl_t = (*s)(j,11);\n \n \n\t\t\t(*c)(j,i) = param->GOAL_T_theta(0,0) * log(1+c_t) + param->GOAL_T_theta(0,1) * (1-l_t);\n// (*c)(j,i) = param->GOAL_T_theta(0,0) * log(0.5+c_t) + param->GOAL_T_theta(0,1) * (1-l_t);\n\n \n\t\t};\n \n\t\t//account for money being spent\n\t\ts->col(0) = s->col(0).array() - w->col(i*3 + 1).array() * s->col(3).array();\n \n \n\t\t//labor payments\n\t\ts->col(0) = s->col(0).array() + s->col(11).array() * s->col(12).array();\n\n \n\t\t//dividend payment\n\t\ts->col(0) += w->col(i*3 + 2);\n \n \n //zero out labor contracts\n s->col(11) = s_zero;\n s->col(12) = s_zero;\n //zero out consumption goods\n s->col(3) = s_zero;\n \n //add value function estimation\n for (int j=0; j < s->rows(); j++){\n s_block = s->block(j,0,1,s->cols());\n \n (*v)(j,i) = _V(s_block,ret, theta_V);\n };\n \n\n\n \n\t};\n \n};\n\n\ndouble\nH::_c_theta_x(Eigen::MatrixXd& theta_x, Eigen::Block& s0, Eigen::MatrixXd& theta_V){\n \n int N = 1;\n double _c = 0.0;\n \n // std::cout << s0 << std::endl;\n \n\t//gets matrix of thetas\n\t//prepare initial matrix\n\tMatrixXd m_s0 = MatrixXd::Zero(N, s0.cols());\n \n\tm_s0.rowwise() += s0.row(0);\n \n \n\t//allocate space to the matrix\n\tMatrixXd n_w;\n\tMatrixXd n_x = MatrixXd::Zero(N, 3);\n\tMatrixXd n_s = MatrixXd::Zero(N, s0.cols());\n MatrixXd v_bf_ret = MatrixXd::Zero(1, param->ADP_BF_N);\n\tMatrixXd n_c = MatrixXd::Zero(N, 1);;\n MatrixXd n_v = MatrixXd::Zero(N, 1);;\n \n \n\t//create random number generators for the implementation\n \n\tboost::normal_distribution<> nd_w1(s0(0,4), pow(s0(0,15),0.5));\n\tboost::normal_distribution<> nd_w2(s0(0,6), pow(s0(0,16),0.5));\n\tboost::normal_distribution<> nd_w3(s0(0,13), pow(s0(0,17),0.5));\n \n\tboost::variate_generator> rng_w1(w.rng, nd_w1);\n \n\tboost::variate_generator> rng_w2(w.rng, nd_w2);\n \n\tboost::variate_generator> rng_w3(w.rng, nd_w3);\n \n \n \n if (w.param->SIMULATION_MODE != \"test\"){\n \n //draw random variables\n //fast realization\n n_w = MatrixXd::Zero(N, 3 * param->T_MAX);\n for (int i = 0; i < N; i++){\n for(int j=0; j< n_w.cols(); j++){\n if (j%3 == 0){\n n_w(i,j) = rng_w1();\n } else {\n if (j%3 == 1){\n n_w(i,j) = rng_w2();\n }else{\n n_w(i,j) = rng_w3();\n };\n \n };\n n_w(i,j) = std::max(0.0, (double)n_w(i,j));\n };\n };\n };\n\n \n \n \n //redraw random in comparative with Python mode\n if (w.param->SIMULATION_MODE == \"test\"){\n n_w = MatrixXd::Zero(N, 3 * param->T_MAX);\n for (int i = 0; i < N; i++){\n for(int j=0; j< n_w.cols(); j++){\n if (j%3 == 0){\n n_w(i,j) = Tools::get_normal(s0(0,4), pow(s0(0,15),0.5), w.myrng);\n } else {\n if (j%3 == 1){\n n_w(i,j) = Tools::get_normal(s0(0,6), pow(s0(0,16),0.5), w.myrng);\n }else{\n n_w(i,j) = Tools::get_normal(s0(0,13), pow(s0(0,17),0.5), w.myrng);\n };\n \n };\n n_w(i,j) = std::max(0.0, (double)n_w(i,j));\n };\n };\n };\n \n //call estimator of results of steps, given theta_x\n n_s = m_s0;\n _step_opt_CS(theta_x, &n_w, &n_x, &n_s, &n_c, &n_v, theta_V, &v_bf_ret, 1);\n _c = (n_c + param->BETA*n_v).mean();\n \n s0.row(0) = n_s.row(0);\n \n \n // std::cout << s0 << std::endl;\n \n return _c;\n \n};\n\n\nvoid\nH::opt_QL(){\n //find best action for the state\n \n //find current bin for the state\n _s0();\n std::vector s_bin = _place_state_QL(s0);\n s_t_bin = s_bin;\n std::vector Q_s;\n \n \n //create list of all indexes that correspond to current state\n for (int i = 0; i < s_bin.size(); i++){\n for (int j = 0; j< Q.cols(); j++){\n if (_is_bin(j, i, s_bin)){\n Q_s.push_back(j);\n };\n \n };\n };\n \n //find index with max Q\n std::vector Q_max;\n double max = Q(4,Q_s.at(0));\n \n for (auto j:Q_s){\n if (Q(4,j) > max){\n max = Q(4,j);\n Q_max.clear();\n Q_max.push_back(j);\n \n }else{\n if (Q(4,j) == max){\n Q_max.push_back(j);\n };\n };\n \n };\n \n \n \n \n boost::random::uniform_01<> _exp_dist;\n double exp_rate = _exp_dist(w.rng);\n \n boost::random::uniform_int_distribution<> Q_dist(0, Q.cols()-1);\n long theta_max_i;\n \n \n if (exp_rate < param->QL_experimental_rate){\n theta_max_i = Q_dist(w.rng);\n }else{\n //pick randomly best action\n if (Q_max.size()>1){\n boost::random::uniform_int_distribution<> Q_max_dist(0, Q_max.size()-1);\n theta_max_i = Q_max.at(Q_max_dist(w.rng));\n \n }else{\n theta_max_i = Q_max.front();\n };\n };\n \n theta_x_t_bin.push_back(theta_max_i);\n \n //transform from index to decision\n theta_x.row(0) = Q.block(s_bin.size(),theta_max_i,3,1).transpose();\n \n};\n\nbool\nH::_is_bin(int j, int i, std::vector& s_bin){\n bool is_bin = false;\n \n if (i < s_bin.size()){\n is_bin = (Q(i,j) == Q_bin.at(i).at(s_bin.at(i))) && _is_bin(j, i+1, s_bin);\n // std::cout << (Q(i,j) == s_bin.at(i)) << std::endl;\n // std::cout << _is_bin(j, i+1, s_bin) << std::endl;\n }else{\n is_bin = true;\n };\n \n return is_bin;\n};\n\n\n\nvoid\nH::wm_update_Q(){\n //updates Q matrix\n //reward\n double R_t1 = account->g_t.at(account->g_t.size()-2);\n \n //new state\n _s0();\n std::vector s_bin = _place_state_QL(s0);\n std::vector Q_s;\n \n \n //create list of all indexes that correspond to current state\n for (int i = 0; i < s_bin.size(); i++){\n for (int j = 0; j< Q.cols(); j++){\n if (_is_bin(j, i+1, s_bin)){\n Q_s.push_back(j);\n };\n \n };\n };\n \n //find index with max Q\n std::vector Q_max;\n double max = Q(4,Q_s.at(0));\n \n for (auto j:Q_s){\n if (Q(4,j) > max){\n max = Q(4,j);\n Q_max.clear();\n Q_max.push_back(j);\n \n }else{\n if (Q(4,j) == max){\n Q_max.push_back(j);\n };\n };\n \n };\n \n //pick best action\n long theta_max_i;\n long max_i;\n if (Q_max.size()>1){\n boost::random::uniform_int_distribution<> Q_max_dist(0, Q_max.size()-1);\n max_i = Q_max_dist(w.rng);\n theta_max_i = Q_max.at(max_i);\n }else{\n theta_max_i = Q_max.front();\n };\n \n \n //update Q value\n Q(4,theta_x_t_bin.back()) = Q(4,theta_x_t_bin.back())\n + Q(5,theta_x_t_bin.back())\n * (R_t1 + param->BETA*Q(4,theta_max_i) - Q(4,theta_x_t_bin.back()));\n // std::cout << Q << std::endl;\n \n};\n\n\n\nvoid\nH::_set_QL(){\n //setup QL matrix\n //create matrix for the grid - small size here\n\tQ_grid = Eigen::MatrixXd::Zero(6,3);\n \n //money and stock of goods on hand\n Q_grid(0,0) = 0.0;\n Q_grid(0,1) = 10.0;\n Q_grid(0,2) = ((Q_grid(0,1) - Q_grid(0,0))/2);\n \n create_decision_grid(Q_grid, 1);\n\n //Q factors\n Q_grid(4,0) = 0.0;\n Q_grid(4,1) = 0.1;\n Q_grid(4,2) = 1.0;\n \n Q_grid(5,0) = param->QL_L; //speed of learning\n Q_grid(5,1) = Q_grid(5,0) + 0.1;\n Q_grid(5,2) = Q_grid(5,0) + 1.0;\n \n if (w.param->SIMULATION_MODE == \"test\"){\n Tools::mgrid_test(Q_grid, &Q);\n \n } else{\n \n Tools::mgrid(Q_grid, &Q);\n };\n \n create_bin_values(Q_grid, Q_bin);\n \n //update Q to push to hiring all of them\n for (int j = 0; j < Q.cols(); j++){\n if (Q(1,j) == Q_bin.at(1).back()){\n Q(4,j) = 0.05;\n };\n };\n \n \n // std::cout << Q << std::endl;\n \n // Tools::print_vector(Q_bin);\n \n};\n\n\nvoid\nH::create_bin_values(Eigen::MatrixXd& _grid, std::vector>& _bin){\n long N_rows = _grid.rows();\n\tint n_steps_i;\n\tdouble n_steps_i_int;\n \n\tdouble val;\n std::vector values_temp;\n \n //create matrix of bin values\n //create list of values\n\tfor (int i=0; i < N_rows; i++){\n\t\t//n_steps\n\t\tn_steps_i_int = (_grid(i,1) - _grid(i,0))/_grid(i,2);\n \n\t\tn_steps_i = static_cast(floor(n_steps_i_int)) + 1;\n \n \n\t\tfor (int j=0; j\nH::_place_state_QL(Eigen::MatrixXd& s){\n std::vector s_bin;\n \n //pick first and compare\n //push values for bins ina vector\n \n bool FLAG_PLACED = false;\n \n int j = Q_bin.at(0).size()-1;\n while ((j>=0) && !FLAG_PLACED){\n \n if (s(0,0) >= Q_bin.at(0).at(j)){\n s_bin.push_back(j);\n FLAG_PLACED = true;\n };\n j -= 1;\n };\n \n return s_bin;\n};\n\nvoid\nH::create_decision_grid(Eigen::MatrixXd& grid, int begin_index){\n int i = begin_index;\n \n if (param->GRID == \"small\"){\n\t\tgrid(i,0) = 0.0;\n\t\tgrid(i,1) = 1.1;\n\t\tgrid(i,2) = 1.0;\n\t\tgrid(i+1,0) = 0.8;\n\t\tgrid(i+1,1) = 1.25;\n\t\tgrid(i+1,2) = 0.2;\n\t\tgrid(i+2,0) = 0.0;\n\t\tgrid(i+2,1) = 1.0;\n\t\tgrid(i+2,2) = 0.5;\n\t};\n \n if (param->GRID == \"big\"){\n\t\tgrid(i,0) = 0.0;\n\t\tgrid(i,1) = 1.1;\n\t\tgrid(i,2) = 1.0;\n\t\tgrid(i+1,0) = 0.1;\n\t\tgrid(i+1,1) = 2.1;\n\t\tgrid(i+1,2) = 0.45;\n\t\tgrid(i+2,0) = 0.0;\n\t\tgrid(i+2,1) = 1.0;\n\t\tgrid(i+2,2) = 0.5;\n \n\t};\n if (param->GRID == \"test\"){\n \n grid(i,0) = 1.0;\n grid(i,1) = 1.1;\n grid(i,2) = 1.0;\n \n grid(i+1,0) = 0.8;\n grid(i+1,1) = 1.2;\n grid(i+1,2) = 1.0;\n \n grid(i+2,0) = 0.5;\n grid(i+2,1) = 1.1;\n grid(i+2,2) = 1.0;\n \n };\n \n \n};\n\nvoid\nH::_set_mRE(){\n //\n mRE_grid = Eigen::MatrixXd::Zero(4,3);\n create_decision_grid(mRE_grid, 0);\n mRE_grid(3,0) = 1.0;\n mRE_grid(3,1) = 1.1;\n mRE_grid(3,2) = 1.0;\n \n if (w.param->SIMULATION_MODE == \"test\"){\n Tools::mgrid_test(mRE_grid, &mRE);\n \n } else{\n \n Tools::mgrid(mRE_grid, &mRE);\n };\n \n \n \n create_bin_values(mRE_grid, mRE_bin);\n \n //update mRE to push to hiring all of them\n for (int j = 0; j < mRE.cols(); j++){\n if (mRE(0,j) == mRE_bin.at(0).back()){\n mRE(3,j) = 1.05;\n };\n };\n \n};\n\n\n\nvoid\nH::opt_mRE(){\n //form matrix of probabilities\n double sum_prob = 0.0;\n \n for (int j=0; jmRE_T);\n };\n \n std::vector probs;\n \n for (int j=0; jmRE_T)/sum_prob);\n };\n \n \n //roll weighted dice\n boost::random::discrete_distribution<> dist(probs.begin(), probs.end());\n \n \n int theta_i = dist(w.rng);\n \n theta_x_t_bin.push_back(theta_i);\n \n //transform from index to decision\n theta_x.row(0) = mRE.block(0,theta_i,3,1).transpose();\n \n};\n\n\n\nvoid\nH::wm_update_mRE(){\n //adjustment matrix\n Eigen::MatrixXd _E_re = Eigen::MatrixXd::Zero(1, mRE.cols());\n \n //reward\n double R_t1 = account->g_t.at(account->g_t.size()-2);\n \n //adjustment\n _E_re = mRE.row(3) * (param->mRE_EPSILON/(mRE.cols()-1));\n \n //include reward\n _E_re(0,theta_x_t_bin.back()) = R_t1 * (1 - param->mRE_EPSILON);\n \n //update whole matrix\n mRE.row(3) = mRE.row(3) * (1 - param->mRE_PHI) + _E_re;\n \n\n};\n\n\n\n\n\n\n\n\n\nbool\nH::_PS_accept_PO(MessagePSSendPayment* mes){\n\treturn true;\n};\n\n\n\nContractBDt0*\nH::_PS_contract(){\n\treturn ass_asCBDt0.front();\n};\n\n\n\n", "meta": {"hexsha": "2933e99c158b8d8823b4e4d22e56111eb4216203", "size": 40303, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/H.cpp", "max_stars_repo_name": "wilfeli/DMGameBasic", "max_stars_repo_head_hexsha": "ccc5e7ba08ee4e1959c60421692540cafb1faeed", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2017-08-11T23:12:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-04T08:54:19.000Z", "max_issues_repo_path": "src/H.cpp", "max_issues_repo_name": "wilfeli/DMGameBasic", "max_issues_repo_head_hexsha": "ccc5e7ba08ee4e1959c60421692540cafb1faeed", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/H.cpp", "max_forks_repo_name": "wilfeli/DMGameBasic", "max_forks_repo_head_hexsha": "ccc5e7ba08ee4e1959c60421692540cafb1faeed", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-08-02T20:23:21.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-02T20:23:21.000Z", "avg_line_length": 22.6421348315, "max_line_length": 110, "alphanum_fraction": 0.4968860879, "num_tokens": 13008, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7431680086124811, "lm_q2_score": 0.46879062662624377, "lm_q1q2_score": 0.34839019644602276}} {"text": "// (C) Copyright Renaud Detry 2007-2015.\n// Distributed under the GNU General Public License and under the\n// BSD 3-Clause License (See accompanying file LICENSE.txt).\n\n/** @file */\n\n#ifdef NUKLEI_HAS_PARTIAL_VIEW\n\n#define CGAL_EIGEN3_ENABLED\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#endif\n\n#include \n#include \n\n#include \n\n#include \n\n#ifdef NUKLEI_HAS_PARTIAL_VIEW\n\ntypedef CGAL::Simple_cartesian K;\ntypedef K::Point_3 Point;\ntypedef K::Plane_3 Plane;\ntypedef K::Vector_3 Vector;\ntypedef K::Segment_3 Segment;\ntypedef K::Line_3 Line;\ntypedef CGAL::Polyhedron_3 Polyhedron;\ntypedef CGAL::AABB_polyhedron_triangle_primitive Primitive;\ntypedef CGAL::AABB_traits Traits;\ntypedef CGAL::AABB_tree Tree;\ntypedef Tree::Object_and_primitive_id Object_and_primitive_id;\ntypedef Tree::Primitive_id Primitive_id;\n\ntypedef CGAL::Point_with_normal_3 Point_with_normal;\ntypedef std::vector PointList;\n\n#endif\n\nnamespace nuklei {\n\n typedef std::vector< std::pair< Vector3, std::vector > > viewcache_t;\n\n#ifdef NUKLEI_HAS_PARTIAL_VIEW\n \n \n inline bool isVisible(const Vector3& wtarget,\n const Vector3& wnormal,\n const Vector3& wcamera,\n const Polyhedron& poly,\n const Tree& tree,\n const coord_t& tolerance)\n {\n if (std::fabs(wnormal.SquaredLength()-1) < FLOATTOL)\n {\n Vector3 ctot = la::normalized(wtarget-wcamera);\n double dot = wnormal.Dot(ctot);\n if (std::acos(std::fabs(dot)) > (80./180*M_PI))\n {\n return false;\n }\n }\n \n Point camera(wcamera.X(), wcamera.Y(), wcamera.Z());\n Point target(wtarget.X(), wtarget.Y(), wtarget.Z());\n \n //double d = dot();\n Segment segment_query(camera,target);\n bool visible = true;\n \n std::list intersections;\n tree.all_intersections(segment_query, std::back_inserter(intersections));\n \n int self_intersect = 0;\n for (std::list::const_iterator intersection = intersections.begin();\n intersection != intersections.end(); ++intersection)\n {\n Object_and_primitive_id op = *intersection;\n CGAL::Object object = op.first;\n Point intersectionPoint;\n if(CGAL::assign(intersectionPoint,object))\n {\n double sq2 = squared_distance(intersectionPoint, target);\n if (sq2 < tolerance*tolerance) self_intersect++;\n }\n else\n {\n // This is very unlikely (p<<0.001)\n //NUKLEI_THROW(\"intersection is not a point!\");\n }\n }\n \n int num_inter = intersections.size();\n if (self_intersect > 1)\n NUKLEI_LOG(\"Number of self-intersections (\" << self_intersect << \") greater than 1\");\n \n if (num_inter == 0)\n visible = true;\n else\n {\n if (num_inter - self_intersect > 0)\n visible = false;\n else\n visible = true;\n }\n if (num_inter > 1 && visible)\n NUKLEI_INFO(\"Strange visibility at\" << target);\n \n return visible;\n \n }\n \n inline bool isVisible(const Vector3& wtarget,\n const Vector3& wcamera,\n const Polyhedron& poly,\n const Tree& tree,\n const coord_t& tolerance)\n {\n return isVisible(wtarget,\n Vector3::ZERO,\n wcamera,\n poly,\n tree,\n tolerance);\n }\n\n#endif\n \n bool KernelCollection::isVisibleFrom(const Vector3& p, const Vector3& viewpoint,\n const coord_t& tolerance) const\n {\n NUKLEI_TRACE_BEGIN();\n#ifdef NUKLEI_HAS_PARTIAL_VIEW\n if (!deco_.has_key(MESH_KEY))\n NUKLEI_THROW(\"Undefined mesh. Call buildMesh() first.\");\n if (!deco_.has_key(AABBTREE_KEY))\n NUKLEI_THROW(\"Undefined AABB tree. Call buildMesh() first.\");\n \n return isVisible(p, viewpoint,\n *deco_.get< boost::shared_ptr >(MESH_KEY),\n *deco_.get< boost::shared_ptr >(AABBTREE_KEY),\n tolerance);\n#else\n NUKLEI_THROW(\"This function requires the partial view build of Nuklei. See http://nuklei.sourceforge.net/doxygen/group__install.html\");\n#endif\n NUKLEI_TRACE_END();\n }\n \n bool KernelCollection::isVisibleFrom(const kernel::r3xs2p& p, const Vector3& viewpoint,\n const coord_t& tolerance) const\n {\n NUKLEI_TRACE_BEGIN();\n#ifdef NUKLEI_HAS_PARTIAL_VIEW\n if (!deco_.has_key(MESH_KEY))\n NUKLEI_THROW(\"Undefined mesh. Call buildMesh() first.\");\n if (!deco_.has_key(AABBTREE_KEY))\n NUKLEI_THROW(\"Undefined AABB tree. Call buildMesh() first.\");\n\n return isVisible(p.loc_, p.dir_, viewpoint,\n *deco_.get< boost::shared_ptr >(MESH_KEY),\n *deco_.get< boost::shared_ptr >(AABBTREE_KEY),\n tolerance);\n#else\n NUKLEI_THROW(\"This function requires the partial view build of Nuklei. See http://nuklei.sourceforge.net/doxygen/group__install.html\");\n#endif\n NUKLEI_TRACE_END();\n }\n\n template\n C KernelCollection::partialView(const Vector3& viewpoint,\n const coord_t& tolerance,\n const bool useViewcache,\n const bool useRayToSurfacenormalAngle) const\n {\n NUKLEI_TRACE_BEGIN();\n\n C index_collection;\n\n if (!useViewcache)\n {\n#ifdef NUKLEI_HAS_PARTIAL_VIEW\n if (!deco_.has_key(MESH_KEY))\n NUKLEI_THROW(\"Undefined mesh. Call buildMesh() first.\");\n if (!deco_.has_key(AABBTREE_KEY))\n NUKLEI_THROW(\"Undefined AABB tree. Call buildMesh() first.\");\n \n const Polyhedron& poly = *deco_.get< boost::shared_ptr >(MESH_KEY);\n const Tree& tree = *deco_.get< boost::shared_ptr >(AABBTREE_KEY);\n \n for (const_iterator v = begin(); v != end(); ++v)\n {\n Vector3 p = v->getLoc();\n Vector3 normal = Vector3::ZERO;\n if (useRayToSurfacenormalAngle)\n normal = kernel::r3xs2p(*v).dir_;\n if (isVisible(p, normal, viewpoint, poly, tree, tolerance))\n index_collection.push_back(std::distance(begin(), v));\n }\n#else\n NUKLEI_THROW(\"This function requires the partial view build of Nuklei. See http://nuklei.sourceforge.net/doxygen/group__install.html\");\n#endif\n }\n else\n {\n if (!deco_.has_key(VIEWCACHE_KEY))\n NUKLEI_THROW(\"Undefined view cache. Call buildPartialViewCache() first.\");\n\n const viewcache_t &viewIndex = *deco_.get< boost::shared_ptr >(VIEWCACHE_KEY);\n \n double minDist = 1e6;\n viewcache_t::const_iterator closest = as_const(viewIndex).begin();\n for (viewcache_t::const_iterator oo = as_const(viewIndex).begin(); oo != viewIndex.end(); ++oo)\n {\n double tmp = (viewpoint-oo->first).SquaredLength();\n if (tmp < minDist*minDist)\n {\n minDist = tmp;\n closest = oo;\n }\n }\n for (std::vector::const_iterator i = closest->second.begin(); i != closest->second.end(); ++i)\n index_collection.push_back(*i);\n }\n return index_collection;\n NUKLEI_TRACE_END();\n }\n \n \n std::vector KernelCollection::partialView(const Vector3& viewpoint,\n const coord_t& tolerance,\n const bool useViewcache,\n const bool useRayToSurfacenormalAngle) const\n {\n NUKLEI_TRACE_BEGIN();\n#ifdef NUKLEI_HAS_PARTIAL_VIEW\n return partialView< std::vector >(viewpoint, tolerance, useViewcache, useRayToSurfacenormalAngle);\n#else\n NUKLEI_THROW(\"This function requires the partial view build of Nuklei. See http://nuklei.sourceforge.net/doxygen/group__install.html\");\n#endif\n NUKLEI_TRACE_END();\n }\n \n \n KernelCollection::const_partialview_iterator KernelCollection::partialViewBegin(const Vector3& viewpoint,\n const coord_t& tolerance,\n const bool useViewcache,\n const bool useRayToSurfacenormalAngle) const\n {\n NUKLEI_TRACE_BEGIN();\n#ifdef NUKLEI_HAS_PARTIAL_VIEW\n \n typedef const_partialview_iterator::index_container\n index_container;\n typedef const_partialview_iterator::index_container_ptr\n index_container_ptr;\n typedef const_partialview_iterator::index_t\n index_t;\n \n index_container_ptr index_collection(new index_container);\n *index_collection = partialView< index_container >(viewpoint, tolerance, useViewcache, useRayToSurfacenormalAngle);\n \n return const_partialview_iterator(begin(), index_collection);\n#else\n NUKLEI_THROW(\"This function requires the partial view build of Nuklei. See http://nuklei.sourceforge.net/doxygen/group__install.html\");\n#endif\n NUKLEI_TRACE_END();\n }\n \n void KernelCollection::buildPartialViewCache(const double meshTol, const bool useRayToSurfacenormalAngle)\n {\n NUKLEI_TRACE_BEGIN();\n#ifdef NUKLEI_HAS_PARTIAL_VIEW\n Vector3 mean = as_const(*this).moments()->getLoc();\n double stdev = as_const(*this).moments()->getLocH();\n \n std::vector< Vector3 > keys;\n for (int o = 0; o < 10000; ++o)\n {\n Vector3 key = Random::uniformDirection3d();\n keys.push_back(key);\n }\n \n {\n double minDist2 = .15;\n std::vector< Vector3 > tmp = keys;\n keys.clear();\n for (std::vector::const_iterator\n i = tmp.begin();\n i != tmp.end(); ++i)\n {\n bool cnt = false;\n Vector3 iLoc = (*i);\n for (std::vector::const_iterator\n j = keys.begin();\n j != keys.end(); ++j)\n {\n if ( (iLoc - *j).SquaredLength() < minDist2*minDist2 )\n {\n cnt = true;\n break;\n }\n }\n if (!cnt)\n {\n keys.push_back(iLoc);\n }\n }\n }\n \n boost::shared_ptr viewIndex(new viewcache_t());\n \n for (unsigned int o = 0; o < keys.size(); ++o)\n {\n Vector3 key = keys.at(o);\n Vector3 vp = mean + key*stdev*20;\n std::vector vi = as_const(*this).partialView(vp, meshTol, false, useRayToSurfacenormalAngle);\n#if 0\n // debug - delete when code is considered stable\n KernelCollection v;\n for (std::vector::iterator i = vi.begin(); i != vi.end(); ++i)\n v.add(as_const(*this).at(*i));\n v.computeKernelStatistics();\n kernel::base::ptr k = v.randomKernel().create();\n k->setLoc(vp);\n v.add(*k);\n v.computeKernelStatistics();\n#endif\n viewIndex->push_back(std::make_pair(key, vi));\n }\n \n if (deco_.has_key(VIEWCACHE_KEY)) deco_.erase(VIEWCACHE_KEY);\n deco_.insert(VIEWCACHE_KEY, viewIndex);\n \n#if 0\n // debug - delete when code is considered stable\n \n for (viewcache_t::iterator o = viewIndex->begin(); o != viewIndex->end(); ++o)\n {\n double d = 1e6;\n KernelCollection near;\n \n for (viewcache_t::iterator oo = viewIndex->begin(); oo != viewIndex->end(); ++oo)\n {\n if (oo == o) continue;\n double dd = (o->first-oo->first).Length();\n if (dd < d) {\n d = dd;\n near.clear();\n for (std::vector::iterator j = oo->second.begin(); j != oo->second.end(); ++j)\n near.add(as_const(*this).at(*j));\n near.computeKernelStatistics();\n if (near.size() == 0) continue;\n kernel::base::ptr k = near.randomKernel().create();\n k->setLoc(mean + oo->first*stdev*20);\n near.add(*k);\n near.computeKernelStatistics();\n }\n }\n for (KernelCollection::iterator i = near.begin(); i != near.end(); ++i)\n {\n ColorDescriptor cd;\n cd.setColor(RGBColor(1, 0, 0));\n i->setDescriptor(cd);\n }\n for (std::vector::iterator j = o->second.begin(); j != o->second.end(); ++j)\n {\n near.add(as_const(*this).at(*j));\n near.back().setLoc(near.back().getLoc()+Vector3(0.001, 0, 0));\n }\n near.computeKernelStatistics();\n if (near.size() == 0) continue;\n kernel::base::ptr k = near.randomKernel().create();\n k->setLoc(mean + o->first*stdev*20);\n near.add(*k);\n near.computeKernelStatistics();\n writeObservations(\"/tmp/v/\" + stringify(std::distance(viewIndex->begin(), o)), near, Observation::SERIAL);\n }\n#endif\n \n#else\n NUKLEI_THROW(\"This function requires the partial view build of Nuklei. See http://nuklei.sourceforge.net/doxygen/group__install.html\");\n#endif\n NUKLEI_TRACE_END();\n\n }\n\n}\n\n", "meta": {"hexsha": "c06735c3dc9009f45fdf036d93ceef84651ef969", "size": 13549, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libnuklei/kernel/KernelCollectionPartialView.cpp", "max_stars_repo_name": "chungying/nuklei", "max_stars_repo_head_hexsha": "23db2a55a1b3260cf913d0ac10b3b27c000ae1a6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "libnuklei/kernel/KernelCollectionPartialView.cpp", "max_issues_repo_name": "chungying/nuklei", "max_issues_repo_head_hexsha": "23db2a55a1b3260cf913d0ac10b3b27c000ae1a6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "libnuklei/kernel/KernelCollectionPartialView.cpp", "max_forks_repo_name": "chungying/nuklei", "max_forks_repo_head_hexsha": "23db2a55a1b3260cf913d0ac10b3b27c000ae1a6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.6203473945, "max_line_length": 141, "alphanum_fraction": 0.6052107167, "num_tokens": 3326, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7956581000631541, "lm_q2_score": 0.4378234991142019, "lm_q1q2_score": 0.3483578134682079}} {"text": "// Boost.Geometry (aka GGL, Generic Geometry Library)\n\n// Copyright (c) 2019 Barend Gehrels, Amsterdam, the Netherlands.\n\n// Use, modification and distribution is subject to the Boost Software License,\n// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_DISTANCE_MEASURE_HPP\n#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_DISTANCE_MEASURE_HPP\n\n#include \n#include \n#include \n#include \n\n#include \n\nnamespace boost { namespace geometry\n{\n\n#ifndef DOXYGEN_NO_DETAIL\nnamespace detail\n{\n\ntemplate \nstruct distance_measure\n{\n T measure;\n\n distance_measure()\n : measure(T())\n {}\n\n bool is_small() const { return true; }\n bool is_zero() const { return true; }\n bool is_positive() const { return false; }\n bool is_negative() const { return false; }\n};\n\ntemplate \nstruct distance_measure_floating\n{\n T measure;\n\n distance_measure_floating()\n : measure(T())\n {}\n\n // Returns true if the distance measure is small.\n // This is an arbitrary boundary, to enable some behaviour\n // (for example include or exclude turns), which are checked later\n // with other conditions.\n bool is_small() const { return std::abs(measure) < 1.0e-3; }\n\n // Returns true if the distance measure is absolutely zero\n bool is_zero() const { return measure == 0.0; }\n\n // Returns true if the distance measure is positive. Distance measure\n // algorithm returns positive value if it is located on the left side.\n bool is_positive() const { return measure > 0.0; }\n\n // Returns true if the distance measure is negative. Distance measure\n // algorithm returns negative value if it is located on the right side.\n bool is_negative() const { return measure < 0.0; }\n};\n\ntemplate <>\nstruct distance_measure\n : public distance_measure_floating {};\n\ntemplate <>\nstruct distance_measure\n : public distance_measure_floating {};\n\ntemplate <>\nstruct distance_measure\n : public distance_measure_floating {};\n\n} // detail\n\n\nnamespace detail_dispatch\n{\n\n// TODO: this is effectively a strategy, but for internal usage.\n// It might be moved to the strategies folder.\n\ntemplate \nstruct get_distance_measure\n : not_implemented\n{};\n\ntemplate \nstruct get_distance_measure\n{\n typedef detail::distance_measure result_type;\n\n template \n static result_type apply(SegmentPoint const& p1, SegmentPoint const& p2,\n Point const& p)\n {\n typedef CalculationType ct;\n\n // Construct a line in general form (ax + by + c = 0),\n // (will be replaced by a general_form structure in next PR)\n ct const x1 = geometry::get<0>(p1);\n ct const y1 = geometry::get<1>(p1);\n ct const x2 = geometry::get<0>(p2);\n ct const y2 = geometry::get<1>(p2);\n ct const a = y1 - y2;\n ct const b = x2 - x1;\n ct const c = -a * x1 - b * y1;\n\n // Returns a distance measure\n // https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line#Line_defined_by_an_equation\n // dividing by sqrt(a*a+b*b) is not necessary for this distance measure,\n // it is not a real distance and purpose is to detect small differences\n // in collinearity\n result_type result;\n result.measure = a * geometry::get<0>(p) + b * geometry::get<1>(p) + c;\n\n return result;\n }\n};\n\ntemplate \nstruct get_distance_measure\n{\n typedef detail::distance_measure result_type;\n\n template \n static result_type apply(SegmentPoint const& , SegmentPoint const& ,\n Point const& )\n {\n // TODO, optional\n result_type result;\n return result;\n }\n};\n\ntemplate \nstruct get_distance_measure\n : get_distance_measure {};\n\n\n} // namespace detail_dispatch\n\nnamespace detail\n{\n\n// Returns a (often very tiny) value to indicate its side, and distance,\n// 0 (absolutely 0, not even an epsilon) means collinear. Like side,\n// a negative means that p is to the right of p1-p2. And a positive value\n// means that p is to the left of p1-p2.\n\ntemplate \nstatic distance_measure::type>\nget_distance_measure(SegmentPoint const& p1, SegmentPoint const& p2, Point const& p)\n{\n return detail_dispatch::get_distance_measure\n <\n typename select_coordinate_type::type,\n cs_tag\n >::apply(p1, p2, p);\n\n}\n\n} // namespace detail\n#endif // DOXYGEN_NO_DETAIL\n\n}} // namespace boost::geometry\n\n#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_DISTANCE_MEASURE_HPP\n", "meta": {"hexsha": "a306cb442168d4271541de52ce482e54f749fbf2", "size": 5351, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "3rdParty/boost/1.71.0/boost/geometry/algorithms/detail/overlay/get_distance_measure.hpp", "max_stars_repo_name": "rajeev02101987/arangodb", "max_stars_repo_head_hexsha": "817e6c04cb82777d266f3b444494140676da98e2", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 12278.0, "max_stars_repo_stars_event_min_datetime": "2015-01-29T17:11:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T21:12:00.000Z", "max_issues_repo_path": "3rdParty/boost/1.71.0/boost/geometry/algorithms/detail/overlay/get_distance_measure.hpp", "max_issues_repo_name": "rajeev02101987/arangodb", "max_issues_repo_head_hexsha": "817e6c04cb82777d266f3b444494140676da98e2", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 9469.0, "max_issues_repo_issues_event_min_datetime": "2015-01-30T05:33:07.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T16:17:21.000Z", "max_forks_repo_path": "3rdParty/boost/1.71.0/boost/geometry/algorithms/detail/overlay/get_distance_measure.hpp", "max_forks_repo_name": "rajeev02101987/arangodb", "max_forks_repo_head_hexsha": "817e6c04cb82777d266f3b444494140676da98e2", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 892.0, "max_forks_repo_forks_event_min_datetime": "2015-01-29T16:26:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-20T07:44:30.000Z", "avg_line_length": 30.5771428571, "max_line_length": 100, "alphanum_fraction": 0.7022986358, "num_tokens": 1222, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6859494678483918, "lm_q2_score": 0.5078118642792044, "lm_q1q2_score": 0.34833327806942005}} {"text": "#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \n\nnamespace scitbx { namespace math {\n\nnamespace {\n\n\n struct chebyshev_base_wrappers\n {\n typedef chebyshev::chebyshev_base<> w_t;\n\n static void\n wrap()\n {\n using namespace boost::python;\n\n class_(\"chebyshev_base\", no_init)\n .def(init((arg(\"n_terms\"),\n arg(\"low_limit\"),\n arg(\"high_limit\") )))\n .def(init const&>\n ((arg(\"n_terms\"),\n arg(\"low_limit\"),\n arg(\"high_limit\"),\n arg(\"cheb_coefs\") )))\n .def(\"f\", (double(w_t::*)(double const&)) &w_t::f)\n .def(\"f\", (scitbx::af::shared(w_t::*)\n (scitbx::af::const_ref const&))\n &w_t::f )\n .def(\"coefs\", &w_t::coefs )\n .def(\"replace\", &w_t::replace )\n ;\n\n }\n\n\n };\n\n\n struct chebyshev_polynome_wrappers\n {\n typedef chebyshev::chebyshev_polynome<> w_t;\n\n static void\n wrap()\n {\n using namespace boost::python;\n\n class_(\"chebyshev_polynome\", no_init)\n .def(init const&>\n ((arg(\"n_terms\"),\n arg(\"low_limit\"),\n arg(\"high_limit\"),\n arg(\"cheb_coefs\") )))\n .def(\"f\", (double(w_t::*)(double const&)) &w_t::f)\n .def(\"f\", (scitbx::af::shared(w_t::*)\n (scitbx::af::const_ref const&))\n &w_t::f )\n .def(\"coefs\", &w_t::coefs )\n\n .def(\"dfdx\", (double(w_t::*)(double const&)) &w_t::dfdx)\n .def(\"dfdx\", (scitbx::af::shared(w_t::*)\n (scitbx::af::const_ref const&))\n &w_t::dfdx )\n .def(\"dfdx_coefs\", &w_t::dfdx_coefs)\n ;\n\n }\n\n\n };\n\n\n struct chebyshev_fitter_wrappers\n {\n typedef chebyshev::chebyshev_fitter<> w_t;\n\n static void\n wrap()\n {\n using namespace boost::python;\n\n class_(\"chebyshev_fitter\", no_init)\n .def(init\n ((arg(\"n_terms\"),\n arg(\"low_limit\"),\n arg(\"high_limit\") )))\n .def(init const&>\n ((arg(\"n_terms\"),\n arg(\"low_limit\"),\n arg(\"high_limit\"),\n arg(\"cheb_coefs\") )))\n\n\n .def(\"f\", (double(w_t::*)(double const&)) &w_t::f)\n .def(\"f\", (scitbx::af::shared(w_t::*)\n (scitbx::af::const_ref const&))\n &w_t::f )\n .def(\"coefs\", &w_t::coefs )\n .def(\"replace\", &w_t::replace)\n .def(\"dfdcoefs\", &w_t::dfdcoefs)\n ;\n\n }\n\n\n };\n\n\n\n\n\n struct chebyshev_smooth_wrappers\n {\n typedef chebyshev::chebyshev_smooth<> w_t;\n\n static void\n wrap()\n {\n using namespace boost::python;\n\n class_(\"chebyshev_smooth\", no_init)\n .def(init((arg(\"n_terms\"),\n arg(\"low_limit\"),\n arg(\"high_limit\") )))\n .def(init const&>\n ((arg(\"n_terms\"),\n arg(\"low_limit\"),\n arg(\"high_limit\"),\n arg(\"cheb_coefs\") )))\n .def(\"f\", (double(w_t::*)(double const&)) &w_t::f)\n .def(\"f\", (scitbx::af::shared(w_t::*)\n (scitbx::af::const_ref const&))\n &w_t::f )\n .def(\"coefs\", &w_t::smooth_coefs )\n .def(\"replace\", &w_t::replace_and_smooth )\n ;\n\n }\n\n\n };\n\n\n\n struct chebyshev_smooth_fitter_wrappers\n {\n typedef chebyshev::chebyshev_smooth_fitter<> w_t;\n\n static void\n wrap()\n {\n using namespace boost::python;\n\n class_(\"chebyshev_smooth_fitter\", no_init)\n .def(init((arg(\"n_terms\"),\n arg(\"low_limit\"),\n arg(\"high_limit\") )))\n .def(init const&>\n ((arg(\"n_terms\"),\n arg(\"low_limit\"),\n arg(\"high_limit\"),\n arg(\"cheb_coefs\") )))\n .def(\"f\", (double(w_t::*)(double const&)) &w_t::f)\n .def(\"f\", (scitbx::af::shared(w_t::*)\n (scitbx::af::const_ref const&))\n &w_t::f )\n .def(\"coefs\", &w_t::smooth_coefs )\n .def(\"replace\", &w_t::replace_and_smooth )\n .def(\"dfdcoefs\", &w_t::dfdcoefs)\n ;\n\n }\n\n\n };\n\n\n\n\n struct chebyshev_lsq_wrappers\n {\n typedef chebyshev::chebyshev_lsq<> w_t;\n\n static void\n wrap()\n {\n using namespace boost::python;\n\n class_(\"chebyshev_lsq\", no_init)\n .def(init const&,\n scitbx::af::const_ref const&,\n scitbx::af::const_ref const&,\n scitbx::af::const_ref const&\n >((arg(\"n_terms\"),\n arg(\"low_limit\"),\n arg(\"high_limit\"),\n arg(\"x_obs\"),\n arg(\"y_obs\"),\n arg(\"w_obs\"),\n arg(\"free_flags\") )))\n\n .def(\"residual\", &w_t::residual)\n .def(\"free_residual\", &w_t::free_residual)\n .def(\"gradient\", &w_t::gradient )\n .def(\"replace\", &w_t::replace )\n .def(\"coefs\", &w_t::coefs)\n ;\n\n }\n\n\n };\n\n\n\n\n\n\n\n\n} // namespace \n\nnamespace boost_python {\n\n\n void wrap_chebyshev_base()\n {\n chebyshev_base_wrappers::wrap();\n }\n void wrap_chebyshev_polynome()\n {\n chebyshev_polynome_wrappers::wrap();\n }\n void wrap_chebyshev_fitter()\n {\n chebyshev_fitter_wrappers::wrap();\n }\n\n void wrap_chebyshev_smooth()\n {\n chebyshev_smooth_wrappers::wrap();\n }\n void wrap_chebyshev_smooth_fitter()\n {\n chebyshev_smooth_fitter_wrappers::wrap();\n }\n\n void wrap_chebyshev_lsq()\n {\n chebyshev_lsq_wrappers::wrap();\n }\n\n\n\n}}} // namespace scitbx::math::boost_python\n", "meta": {"hexsha": "a442b3fe0141da2946f86c9aca73598745dacd1b", "size": 7240, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "scitbx/math/boost_python/chebyshev.cpp", "max_stars_repo_name": "rimmartin/cctbx_project", "max_stars_repo_head_hexsha": "644090f9432d9afc22cfb542fc3ab78ca8e15e5d", "max_stars_repo_licenses": ["BSD-3-Clause-LBNL"], "max_stars_count": 155.0, "max_stars_repo_stars_event_min_datetime": "2016-11-23T12:52:16.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T15:35:44.000Z", "max_issues_repo_path": "scitbx/math/boost_python/chebyshev.cpp", "max_issues_repo_name": "rimmartin/cctbx_project", "max_issues_repo_head_hexsha": "644090f9432d9afc22cfb542fc3ab78ca8e15e5d", "max_issues_repo_licenses": ["BSD-3-Clause-LBNL"], "max_issues_count": 590.0, "max_issues_repo_issues_event_min_datetime": "2016-12-10T11:31:18.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T23:10:09.000Z", "max_forks_repo_path": "scitbx/math/boost_python/chebyshev.cpp", "max_forks_repo_name": "rimmartin/cctbx_project", "max_forks_repo_head_hexsha": "644090f9432d9afc22cfb542fc3ab78ca8e15e5d", "max_forks_repo_licenses": ["BSD-3-Clause-LBNL"], "max_forks_count": 115.0, "max_forks_repo_forks_event_min_datetime": "2016-11-15T08:17:28.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-09T15:30:14.000Z", "avg_line_length": 24.8797250859, "max_line_length": 64, "alphanum_fraction": 0.4914364641, "num_tokens": 1905, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6859494550081926, "lm_q2_score": 0.5078118642792044, "lm_q1q2_score": 0.34833327154901456}} {"text": "/*\n * Copyright (c) 2019 Opticks Team. All Rights Reserved.\n *\n * This file is part of Opticks\n * (see https://bitbucket.org/simoncblyth/opticks).\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); \n * you may not use this file except in compliance with the License. \n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software \n * distributed under the License is distributed on an \"AS IS\" BASIS, \n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. \n * See the License for the specific language governing permissions and \n * limitations under the License.\n */\n\n \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"NPY.hpp\"\n#include \"NPlanck.hpp\"\n#include \"NCIE.hpp\"\n\n#include \"GAry.hh\"\n#include \"GDomain.hh\"\n\n#include \"PLOG.hh\"\n\n\n\ntemplate \nT GAry::np_interp(const T z, GAry* xp, GAry* fp )\n{\n // input domain and values\n // \n // :param z: \"x\" domain value for which the interpolated \"y\" value is to be obtained\n // :param xp : domain x-coordinates of the data points, must be increasing.\n // :param fp : value y-coordinates of the data points, same length as `xp`.\n // \n // :return: y value (ie linear interpolation of fp values) corresponding to the ordinate supplied \n // \n\n T* dx = xp->getValues(); \n\n T* dy = fp->getValues(); \n T left = fp->getLeft();\n T right = fp->getRight();\n\n int len = xp->getLength();\n \n assert( len > 0 );\n \n if(dy[len-1] != right )\n {\n LOG(warning) << \"GAry::np_interp \"\n << \" len \" << len\n << \" dy[len-1] \" << dy[len-1]\n << \" right \" << right\n << \" left \" << left\n ;\n }\n\n assert(dy[len-1] == right );\n\n\n/*\n This assert is firing occasionally... but unreproducibly \n\n[2015-Jul-22 15:28:16.828602]: GProperty::save 2d array of length 275 to : /tmp/reemissionCDF.npy\ncreateZeroTrimmed ifr 0 ito 273 \nnp_sliced ifr 0 ito 273 alen 275 blen 273 \nnp_sliced ifr 0 ito 273 alen 275 blen 273 \nGBoundaryLib::createReemissionBuffer icdf : 570b234e132f398d4213400cc88f427b : 4096 \nd 0.000 0.063 0.125 0.188 0.250 0.313 0.375 0.438 0.500 0.563 0.625 0.688 0.750 0.813 0.875 0.938\nv 799.898 463.793 450.234 441.314 434.113 428.762 424.561 420.824 417.127 413.177 408.946 404.907 401.409 398.164 394.649 389.214\n[2015-Jul-22 15:28:16.834756]: GProperty::save 2d array of length 4096 to : /tmp/invertedReemissionCDF.npy\nAssertion failed: (dy[len-1] == right), function np_interp, file /Users/blyth/env/optix/ggeo/GAry.cc, line 39.\nAbort trap: 6\n\n[2015-Jul-24 10:30:36.403821]: GProperty::save 2d array of length 4096 to : /tmp/invertedReemissionCDF.npy\n[2015-Jul-24 10:30:36.443812]: GAry::np_interp len 4096 dy[len-1] nan right nan left 799.898\nAssertion failed: (dy[len-1] == right), function np_interp, file /Users/blyth/env/optix/ggeo/GAry.cc, line 50.\n/Users/blyth/env/graphics/ggeoview/ggeoview.bash: line 550: 2369 Abort trap: 6 $bin $*\n\n*/\n\n T ival ;\n int j = xp->binary_search(z); // find low side domain index corresponding to domain value z\n if(j == -1)\n {\n ival = left;\n }\n else if(j == len - 1)\n {\n ival = dy[j]; // right \n }\n else if(j == len )\n {\n ival = right;\n }\n else\n {\n const T slope = (dy[j + 1] - dy[j])/(dx[j + 1] - dx[j]);\n ival = slope*(z - dx[j]) + dy[j];\n }\n return ival ; \n}\n\n\ntemplate \nGAry* GAry::np_interp(GAry* xi, GAry* xp, GAry* fp )\n{\n //\n // Loosely follow np.interp signature and implementation from \n // https://github.com/numpy/numpy/blob/v1.9.1/numpy/lib/src/_compiled_base.c#L599\n //\n\n assert(xp->getLength() == fp->getLength()); // input domain and values must be of same length\n\n GAry* res = new GAry(xi->getLength()); // Ary to be filled with interpolated values\n T* dres = res->getValues();\n\n for (unsigned int i = 0; i < res->getLength() ; i++) \n {\n dres[i] = np_interp( xi->getValue(i), xp, fp ) ;\n }\n return res ;\n}\n\ntemplate \nGAry* np_product(GAry* a, GAry* b)\n{\n assert(a->getLength() == b->getLength()); \n GAry* prod = new GAry(a->getLength()); // Ary to be filled with interpolated values\n for (unsigned int i = 0; i < prod->getLength() ; i++) \n {\n T ab = a->getValue(i) * b->getValue(i);\n prod->setValue(i, ab );\n }\n return prod ;\n}\n\ntemplate \nGAry* np_subtract(GAry* a, GAry* b)\n{\n assert(a->getLength() == b->getLength()); \n GAry* result = new GAry(a->getLength()); \n for (unsigned int i = 0; i < result->getLength() ; i++) \n {\n T ab = b->getValue(i) - a->getValue(i);\n result->setValue(i, ab );\n }\n return result ;\n}\n\n\ntemplate \nGAry* np_add(GAry* a, GAry* b)\n{\n assert(a->getLength() == b->getLength()); \n GAry* result = new GAry(a->getLength()); \n for (unsigned int i = 0; i < result->getLength() ; i++) \n {\n T ab = b->getValue(i) + a->getValue(i);\n result->setValue(i, ab );\n }\n return result ;\n}\n\n\ntemplate \nGAry* np_clip(GAry* a, GAry* low, GAry* high, GAry* low_fallback, GAry* high_fallback )\n{\n assert(a->getLength() == low->getLength()); \n assert(a->getLength() == high->getLength()); \n if(low_fallback) assert(a->getLength() == low_fallback->getLength()); \n if(high_fallback) assert(a->getLength() == high_fallback->getLength()); \n\n GAry* cc = new GAry(a->getLength()); \n for (unsigned int i = 0; i < cc->getLength() ; i++) \n {\n T aa = a->getValue(i);\n T lo = low->getValue(i);\n T hi = high->getValue(i);\n\n if( aa < lo )\n {\n cc->setValue(i, low_fallback ? low_fallback->getValue(i) : lo );\n }\n else if(aa > hi )\n {\n cc->setValue(i, high_fallback ? high_fallback->getValue(i) : hi );\n }\n else\n {\n cc->setValue(i, aa );\n\n }\n }\n return cc ;\n}\n\n\n\n\n\ntemplate \nT np_maxdiff(GAry* a, GAry* b, bool dump)\n{\n\n unsigned alen = a->getLength() ;\n unsigned blen = b->getLength() ;\n \n if(dump) LOG(info) << \" np_maxdiff \" \n << \" a \" << std::setw(5) << alen\n << \" b \" << std::setw(5) << blen\n ;\n\n assert(alen == blen); \n T max(0);\n for (unsigned int i = 0; i < a->getLength() ; i++) \n {\n T av = a->getValue(i);\n T bv = b->getValue(i);\n T ab = bv - av ;\n\n max = std::max( max, ab );\n\n if(dump) LOG(info) \n << \" i \" << std::setw(4) << i\n << \" av \" << std::setw(10) << av \n << \" bv \" << std::setw(10) << bv \n << \" ab \" << std::setw(10) << ab \n ; \n\n }\n\n if(dump) LOG(info) << \" maxdiff \" << max ; \n\n return max ;\n}\n\n\n\n\n\n\ntemplate \nGAry* np_cumsum(GAry* y, unsigned int offzero)\n{\n unsigned int len = y->getLength();\n GAry* cy = new GAry(len+offzero); // Ary to be filled with cumsum values\n T sum(0);\n for (unsigned int j = 0; j < offzero ; j++) \n {\n cy->setValue(j, 0);\n }\n for (unsigned int i = 0; i < len ; i++) \n {\n sum += y->getValue(i);\n cy->setValue(offzero+i, sum);\n }\n return cy ;\n}\n\ntemplate \nGAry* np_reversed(GAry* y, bool reciprocal, T scale)\n{\n unsigned int len = y->getLength();\n GAry* ry = new GAry(len); \n\n for (unsigned int i = 0; i < len ; i++)\n {\n T val = y->getValue(i) ; \n ry->setValue(len-1-i, reciprocal ? scale/val : scale*val );\n }\n return ry ;\n}\n\n\ntemplate \nGAry* GAry::reciprocal(GAry* y, T scale)\n{\n unsigned int len = y->getLength();\n GAry* ry = new GAry(len); \n for (unsigned int i = 0; i < len ; i++)\n {\n T val = y->getValue(i) ; \n ry->setValue(i, scale/val );\n }\n return ry ;\n}\n\n\n\n\ntemplate \nGAry* g4_groupvel_bintrick(GAry* y)\n{\n /*\n This curious bin shifting is used by G4 GROUPVEL calc\n\n In order not to loose a bin\n a tricky manoever of using the 1st and last bin and \n the average of the body bins\n which means the first bin is half width, and last is 1.5 width\n \n ::\n\n 0 + 1 + 2 + 3 + 4 + 5 <--- 6 original values\n | / / / / |\n | / / / / |\n 0 1 2 3 4 5 <--- still 6 \n\n\n bb = np.zeros_like(aa)\n bb[0] = aa[0]\n bb[1:-1] = (aa[1:-1] + aa[:-2])/2.\n bb[-1] = aa[-1]\n return bb\n\n */\n\n GAry& Y = *y ;\n unsigned int len = y->getLength();\n GAry* ry = new GAry(len); \n\n ry->setValue(0 , Y[0]);\n ry->setValue(len-1, Y[-1]);\n\n T two(2);\n\n for (unsigned i = 1; i < len - 1 ; i++)\n {\n T val = (Y[i-1] + Y[i])/two ; \n ry->setValue(i, val );\n }\n return ry ;\n}\n\ntemplate \nGAry* np_gradient(GAry* y)\n{\n /*\n Take a look at np.gradient??\n\n The gradient is computed using second order accurate central differences\n in the interior and either first differences or second order accurate \n one-sides (forward or backwards) differences at the boundaries. The\n returned gradient hence has the same shape as the input array.\n\n 0 <--- (0,1) \n \n 1 <--- (0,2)/2\n 2 <--- (1,3)/2\n 3 <-- (2,4)/2\n 4 <-- (3,5)/2\n 5 <-- (4,6)/2\n 6 <-- (5,7)/2\n 7 <-- (6,8)/2\n 8 <-- (7,9)/2\n\n 9 <-- (8,9) \n\n ::\n\n out = np.zeros_like(y)\n out[0] = y[1] - y[0]\n out[1:-1] = (y[2:]-y[:-2])/2.0\n out[-1] = y[-1] - y[-2]\n return o\n */\n\n GAry& Y = *y ;\n unsigned int len = y->getLength();\n assert(len >= 2 );\n T two(2);\n\n GAry* g = new GAry(len); \n g->setValue(0 , Y[1] - Y[0] );\n for (unsigned i = 1; i < len - 1 ; i++) g->setValue(i, (Y[i+1] - Y[i-1])/two );\n g->setValue(len-1, Y[-1] - Y[-2]);\n\n return g ;\n}\n\n\ntemplate \nGAry* np_sliced(GAry* a, int ifr, int ito)\n{\n /*\n\nIn [13]: a = np.linspace(0,1,11)\n\nIn [14]: a\nOut[14]: array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])\n\nIn [16]: a[0:-1]\nOut[16]: array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])\n\nIn [17]: a[0:11]\nOut[17]: array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])\n\n */\n int alen = a->getLength();\n if(ifr < 0 ) ifr += alen ; \n if(ito < 0 ) ito += alen ; \n assert(ifr >=0 && ifr < alen);\n assert(ito >=0 && ito <= alen);\n\n int blen = ito - ifr ; // py style 0-based one-beyond \"ito\"\n assert( ito >= ifr );\n\n //printf(\"Gary.cc:np_sliced ifr %d ito %d alen %u blen %u \\n\", ifr, ito, alen, blen ); \n\n GAry* b = new GAry(blen); \n\n for (int ia = 0; ia < alen ; ia++)\n {\n if( ia >= ifr && ia < ito )\n {\n unsigned int ib = ia - ifr ;\n T val = a->getValue(ia) ; \n b->setValue( ib, val );\n }\n } \n return b ;\n}\n\n\n\n\n\ntemplate \nGAry* np_diff(GAry* y)\n{\n unsigned int len = y->getLength() ;\n GAry* dy = new GAry(len - 1); \n for (unsigned int i = 0; i < len - 1 ; i++)\n {\n T diff = y->getValue(i+1) - y->getValue(i) ; \n dy->setValue(i, diff );\n }\n return dy ;\n}\n\ntemplate \nGAry* np_mid(GAry* y)\n{\n unsigned int len = y->getLength() ;\n GAry* my = new GAry(len - 1); \n T two(2);\n for (unsigned int i = 0; i < len - 1 ; i++)\n {\n T mid = (y->getValue(i) + y->getValue(i+1))/two ; \n my->setValue(i, mid );\n }\n return my ;\n}\n\n\ntemplate \nGAry* GAry::urandom(unsigned int length)\n{\n GAry* u = new GAry(length); \n T* vals = u->getValues();\n\n typedef boost::mt19937 RNG_t;\n typedef boost::uniform_real<> Distrib_t;\n typedef boost::variate_generator< RNG_t, Distrib_t > Generator_t ;\n\n RNG_t rng;\n Distrib_t distrib(0,1);\n Generator_t gen(rng, distrib); \n\n for (unsigned int i = 0; i < length ; i++) vals[i] = gen();\n return u ;\n}\n\n\ntemplate \nGAry* GAry::from_domain(GDomain* domain)\n{\n GAry* ary = new GAry( domain->getLength(), domain->getValues() );\n return ary ; \n}\n\n\ntemplate \nGAry* GAry::planck_spectral_radiance(GAry* nm, T blackbody_temp_kelvin)\n{\n T* nmv = nm->getValues();\n GAry* ary = new GAry( nm->getLength(), NULL );\n T* vals = ary->getValues();\n for(unsigned int i=0 ; i < ary->getLength(); i++) vals[i] = ::planck_spectral_radiance(nmv[i], blackbody_temp_kelvin) ; \n return ary ;\n}\n\ntemplate \nGAry* GAry::cie_weight(GAry* nm, unsigned int component)\n{\n T* nmv = nm->getValues();\n GAry* ary = new GAry( nm->getLength(), NULL );\n T* vals = ary->getValues();\n for(unsigned int i=0 ; i < ary->getLength(); i++) \n {\n switch(component)\n {\n case 0:vals[i] = NCIE::X(nmv[i]) ;break; \n case 1:vals[i] = NCIE::Y(nmv[i]) ;break; \n case 2:vals[i] = NCIE::Z(nmv[i]) ;break; \n }\n }\n return ary ;\n}\n\n\ntemplate \nGAry* GAry::cie_X(GAry* nm)\n{\n return cie_weight(nm, 0);\n}\ntemplate \nGAry* GAry::cie_Y(GAry* nm)\n{\n return cie_weight(nm, 1);\n}\ntemplate \nGAry* GAry::cie_Z(GAry* nm)\n{\n return cie_weight(nm, 2);\n}\n\n\n\n\n\n\n\n\n\ntemplate \nGAry* GAry::create_from_floats(unsigned int length, float* values)\n{\n // promoting floats to doubles\n T* tvalues = new T[length];\n for(unsigned int i=0 ; i < length ; i++) tvalues[i] = values[i];\n GAry* ary = new GAry(length, tvalues);\n delete[] tvalues ; \n return ary ;\n}\n\ntemplate \nGAry* GAry::product(GAry* a, GAry* b)\n{\n return np_product(a, b);\n}\n\ntemplate \nGAry* GAry::subtract(GAry* a, GAry* b)\n{\n return np_subtract(a, b);\n}\ntemplate \nGAry* GAry::add(GAry* a, GAry* b)\n{\n return np_add(a, b);\n}\n\n\ntemplate \nGAry* GAry::clip(GAry* low, GAry* high, GAry* low_fallback, GAry* high_fallback )\n{\n return np_clip(this, low, high, low_fallback, high_fallback );\n}\n\n\ntemplate \nT GAry::maxdiff(GAry* a, GAry* b, bool dump)\n{\n return np_maxdiff(a, b, dump);\n}\n\ntemplate \nGAry* GAry::reciprocal(T scale_)\n{\n return reciprocal(this, scale_);\n}\n\n\n\n\n\n\ntemplate \nGAry* GAry::from_constant(unsigned int length, T value )\n{\n GAry* ary = new GAry( length, NULL );\n T* vals = ary->getValues();\n for(unsigned int i=0 ; i < length; i++) vals[i] = value ;\n return ary ;\n} \n\n\ntemplate \nGAry* GAry::zeros(unsigned int length)\n{\n return GAry::from_constant(length, 0);\n} \n\ntemplate \nGAry* GAry::ones(unsigned int length)\n{\n return GAry::from_constant(length, 1);\n} \n\n\n\n\n\ntemplate \nGAry* GAry::ramp(unsigned int length, T low, T step )\n{\n GAry* ary = new GAry( length, NULL );\n T* vals = ary->getValues();\n for(unsigned int i=0 ; i < length; i++) vals[i] = low + step*i ; \n return ary ;\n} \n\n\ntemplate \nT GAry::step(T num, T start, T stop)\n{\n return (stop - start)/(num - 1) ; \n}\n\ntemplate \nGAry* GAry::linspace(T num, T start, T stop)\n{\n /*\nIn [11]: np.linspace(0,1,10)\nOut[11]: \narray([ 0. , 0.111, 0.222, 0.333, 0.444, 0.556, 0.667, 0.778,\n 0.889, 1. ])\n\nIn [12]: np.linspace(0,1,11)\nOut[12]: array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])\n\n */\n T step_ = step(num, start, stop);\n GAry* ary = new GAry( num, NULL );\n T* vals = ary->getValues();\n for(unsigned int i=0 ; i < num ; i++) vals[i] = start + step_*i ; \n return ary ;\n} \n\n\ntemplate \nGAry* GAry::copy() \n{\n return new GAry(this);\n}\n\ntemplate \nGAry::GAry(GAry* other) : m_length(other->getLength())\n{\n m_values = new T[m_length];\n for(unsigned int i=0 ; i < m_length; i++) m_values[i] = other->getValue(i) ;\n}\n\ntemplate \nGAry::GAry(unsigned int length, T* values) : m_length(length)\n{\n m_values = new T[m_length];\n if(values)\n {\n for(unsigned int i=0 ; i < length; i++) m_values[i] = values[i] ;\n }\n} \n\ntemplate \nGAry::~GAry() \n{\n delete m_values ;\n}\n\n\n\ntemplate \nvoid GAry::setValues(T val)\n{\n for(unsigned int i=0 ; i < m_length; i++) m_values[i] = val ;\n}\n\n\ntemplate \nGAry* GAry::cumsum(unsigned int offzero)\n{ \n return np_cumsum(this, offzero) ; \n}\n\ntemplate \nGAry* GAry::g4_groupvel_bintrick()\n{ \n return ::g4_groupvel_bintrick(this) ; \n}\n\ntemplate \nGAry* GAry::gradient()\n{ \n return ::np_gradient(this) ; \n}\n\n\n\n\n\n\n\ntemplate \nGAry* GAry::diff()\n{ \n return np_diff(this) ; \n} // domain bin widths\n\ntemplate \nGAry* GAry::mid()\n{ \n return np_mid(this) ; \n} // average of values at bin edges, ie linear approximation of mid bin \"y\" value \n\ntemplate \nGAry* GAry::reversed(bool reciprocal_, T scale_)\n{ \n return np_reversed(this, reciprocal_, scale_) ; \n}\n\ntemplate \nGAry* GAry::sliced(int ifr_, int ito_)\n{ \n return np_sliced(this, ifr_, ito_) ; \n}\n\n\n\ntemplate \nvoid GAry::Summary(const char* msg, unsigned int imod, T presentation_scale)\n{\n printf(\"%s length %u leftzero %u rightzero %u \\n\", msg, m_length, getLeftZero(), getRightZero() );\n\n if(m_length < 100)\n {\n for(unsigned int i=0 ; i < m_length ; i++ ) if(i%imod == 0) printf(\" %10.3f \", getValue(i)*presentation_scale);\n printf(\"\\n\");\n }\n else\n {\n for(unsigned int i=0 ; i < m_length ; i++ ) \n {\n if( i < 10 || i > m_length - 10 )\n {\n printf(\" %10.3f \", getValue(i)*presentation_scale);\n } \n else if ( i == 10 )\n {\n printf(\" ... \");\n }\n }\n printf(\"\\n\");\n }\n\n T rng[2] ;\n unsigned int idx[2] ;\n rng[0] = min(idx[0]);\n rng[1] = max(idx[1]);\n\n printf(\"mi/mx idx %u %u range %15.5f %15.5f 1/range %15.5f %15.5f \\n\", idx[0], idx[1], rng[0], rng[1], 1./rng[0], 1./rng[1] );\n\n} \n\n\ntemplate \nT GAry::getValueFractional(T findex)\n{\n unsigned int idx(findex);\n T dva ; \n\n if(idx + 1 < m_length )\n {\n T frac(findex - T(idx));\n dva = m_values[idx]*(1.-frac) + m_values[idx+1]*frac ;\n }\n else\n {\n dva = m_values[m_length-1]; \n } \n return dva ; \n}\n\ntemplate \nT GAry::getValueLookup(T u)\n{\n // convert u (0:1) into fractional bin, and use that to lookup values\n assert( u <= 1. && u >= 0. );\n T findex = u * (m_length - 1) ; \n return getValueFractional(findex);\n}\n\ntemplate \nunsigned int GAry::getLeftZero()\n{\n // when the values start with a string of zeros, \n // return the index of rightmost such zero minus 1, \n // otherwise return 0\n\n T zero(0);\n int ifr(0);\n for(unsigned int i=0 ; i < m_length ; i++)\n {\n if( m_values[i] == zero ) ifr = i ;\n else\n break ; \n }\n\n return ifr > 0 ? ifr - 1 : 0 ; \n}\n\n\ntemplate \nunsigned int GAry::getRightZero()\n{\n // when the values end with a string of zeros, \n // return the lowest index + 1, \n // otherwise return m_length\n\n T zero(0);\n unsigned int ito(m_length);\n for(unsigned int i=0 ; i < m_length ; i++)\n {\n unsigned int j = m_length - 1 - i ; // looks at bins from the right \n if( m_values[j] == zero ) ito = j ;\n else\n break ; \n }\n return ito < m_length ? ito + 1 : m_length ; \n}\n\n\n\ntemplate \nvoid GAry::add(GAry* other)\n{ \n assert(other->getLength() == m_length);\n for(unsigned int i=0 ; i < m_length ; i++ ) m_values[i] += other->getValue(i) ; \n}\n\ntemplate \nvoid GAry::subtract(GAry* other)\n{ \n assert(other->getLength() == m_length);\n for(unsigned int i=0 ; i < m_length ; i++ ) m_values[i] -= other->getValue(i) ; \n}\n\n\n\n\ntemplate \nvoid GAry::scale(T sc)\n{\n for(unsigned int i=0 ; i < m_length ; i++ ) m_values[i] *= sc ; \n} \n\ntemplate \nvoid GAry::reciprocate()\n{\n T one(1);\n for(unsigned int i=0 ; i < m_length ; i++ ) m_values[i] = one/m_values[i] ; \n} \n\ntemplate \nint GAry::linear_search(T key)\n{\n // for checking edge case behaviour of binary_search\n // expected to return same values as binary_search more slowly\n\n if(key < m_values[0]) \n {\n return -1 ; // indicates \"below-lower-bound\"\n }\n else if(key > m_values[m_length-1]) \n {\n return m_length ; // indicates \"above-upper-bound\"\n }\n else if(key == m_values[m_length-1])\n {\n return m_length - 1 ; // at upper bound \n }\n else\n {\n for(unsigned int i=0 ; i < m_length - 1 ; ++i )\n {\n // m_values[0] : m_values[1]\n // ...\n // m_values[m_length-2] : m_values[m_length-1] \n //\n if(key >= m_values[i] && key < m_values[i+1]) return i ;\n }\n } \n assert(0); // not expected here\n return -2 ; \n}\n \n\n\ntemplate \nint GAry::binary_search(T key)\n{\n // Find bin index containing the key \n //\n // :param key: value to be \"placed\" within the sequence of ascending values\n // :return: index of the low side value \n //\n // * normally index is range 0:m_length-1\n // * if the key exceeds m_values[m_length-1] m_length is returned, meaning \"to the right\" \n //\n // NB this is used by np_interp \n\n if(key > m_values[m_length-1])\n {\n return m_length ;\n }\n unsigned int imin = 0 ; \n unsigned int imax = m_length ; \n unsigned int imid ; \n\n while(imin < imax)\n {\n imid = imin + ((imax - imin) >> 1);\n if (key >= m_values[imid]) \n {\n imin = imid + 1;\n }\n else \n {\n imax = imid;\n }\n }\n\n assert( imin == imax );\n //if(imin != imax ) printf(\"GAry::binary_search key %10.5f imin %u imax %u len %u \\n\", key, imin, imax, m_length );\n\n return imin - 1; \n} \n\n\ntemplate \nT GAry::fractional_binary_search(T u)\n{\n // the advantage in dealing in fractional indices\n // is can delay resorting to using domain information for a bit longer\n\n int idx = binary_search(u);\n T frac = (u - m_values[idx])/(m_values[idx+1]-m_values[idx]); // fraction of bin \n return T(idx) + frac ; \n}\n\n\n\ntemplate \nunsigned int GAry::sample_cdf(T u)\n{\n // other than edge cases, this gives same results as binary_search\n\n int lower = 0;\n int upper = m_length - 1;\n\n while(lower < upper-1)\n { \n int half = (lower + upper) / 2;\n if (u < m_values[half])\n {\n upper = half;\n }\n else \n {\n lower = half;\n }\n } \n\n assert( lower == upper - 1 );\n return lower ; \n}\n\n\ntemplate \nT GAry::min(unsigned& idx) const \n{\n T mi(FLT_MAX);\n for(unsigned int i=0 ; i < m_length ; i++ )\n {\n T v = m_values[i];\n if(v < mi)\n {\n mi = v ; \n idx = i ;\n }\n }\n return mi ; \n}\n\ntemplate \nT GAry::max(unsigned& idx) const \n{\n T mx(-FLT_MAX);\n for(unsigned int i=0 ; i < m_length ; i++ )\n {\n T v = m_values[i];\n if(v > mx)\n {\n mx = v ; \n idx = i ;\n }\n }\n return mx ; \n}\n\n\ntemplate \nvoid GAry::save(const char* path)\n{\n std::vector shape ; \n shape.push_back(m_length);\n\n std::string metadata = \"{}\" ; \n\n std::vector data ; \n for(unsigned int i=0 ; i < m_length ; i++ ) data.push_back(m_values[i]) ;\n\n LOG(info) << \"GAry::save 1d array of length \" << m_length << \" to : \" << path ; \n NPY npy(shape, data, metadata);\n npy.save(path);\n}\n\n\n\n\n/*\n* :google:`move templated class implementation out of header`\n* http://www.drdobbs.com/moving-templates-out-of-header-files/184403420\n\nA compiler warning \"declaration does not declare anything\" was avoided\nby putting the explicit template instantiation at the tail rather than the \nhead of the implementation.\n*/\n\ntemplate class GAry;\ntemplate class GAry; // needs work on NPY for this\n\n\n\n", "meta": {"hexsha": "6f9f44bfe9f2e9b5847e64b5c0f816e0de87cbad", "size": 25366, "ext": "cc", "lang": "C++", "max_stars_repo_path": "ggeo/GAry.cc", "max_stars_repo_name": "hanswenzel/opticks", "max_stars_repo_head_hexsha": "b75b5929b6cf36a5eedeffb3031af2920f75f9f0", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2020-07-05T02:39:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-20T18:52:44.000Z", "max_issues_repo_path": "ggeo/GAry.cc", "max_issues_repo_name": "hanswenzel/opticks", "max_issues_repo_head_hexsha": "b75b5929b6cf36a5eedeffb3031af2920f75f9f0", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ggeo/GAry.cc", "max_forks_repo_name": "hanswenzel/opticks", "max_forks_repo_head_hexsha": "b75b5929b6cf36a5eedeffb3031af2920f75f9f0", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2020-09-03T20:36:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-19T07:42:21.000Z", "avg_line_length": 23.6182495345, "max_line_length": 178, "alphanum_fraction": 0.5446660885, "num_tokens": 8140, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.6654105653819836, "lm_q1q2_score": 0.3482894303181545}} {"text": "/* CirKit: A circuit toolkit\n * Copyright (C) 2009-2015 University of Bremen\n * Copyright (C) 2015-2017 EPFL\n *\n * Permission is hereby granted, free of charge, to any person\n * obtaining a copy of this software and associated documentation\n * files (the \"Software\"), to deal in the Software without\n * restriction, including without limitation the rights to use,\n * copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the\n * Software is furnished to do so, subject to the following\n * conditions:\n *\n * The above copyright notice and this permission notice shall be\n * included in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n * OTHER DEALINGS IN THE SOFTWARE.\n */\n#include \"read_pla_to_cirkit_bdd.hpp\"\n\n#include \n#include \n\n#include \n\n#include \n#include \n#include \n\nnamespace cirkit\n{\n\nnamespace\n{\n\nclass from_bdd_pla_processor : public pla_processor\n{\npublic:\n explicit from_bdd_pla_processor( unsigned log_max_objs, bool verbose )\n : m_log_max_objs( log_max_objs ),\n m_verbose( verbose )\n {}\n\n void on_comment(const std::string &comment)\n {\n }\n\n void on_num_inputs(unsigned num_inputs)\n {\n m_inputs = num_inputs;\n m_timer.restart();\n }\n\n void on_num_outputs(unsigned num_outputs) final\n {\n m_outputs = num_outputs;\n }\n\n void on_num_products(unsigned num_products) final\n {\n }\n\n void on_input_labels(const std::vector &input_labels) final\n {\n m_inputNames = input_labels;\n }\n\n void on_output_labels(const std::vector &output_labels) final\n {\n m_outputNames = output_labels;\n }\n\n void on_end() final\n {\n if ( true /* m_verbose */ )\n {\n std::cout\n << boost::format (\"[i] took %.2f seconds to reading pla-file into BDD.\") % m_timer.elapsed()\n << std::endl;\n }\n }\n\n void on_type(const std::string &type)\n {\n }\n\n void setPortNames()\n {\n assert( m_inputNames.size() <= m_inputs );\n assert( m_outputNames.size() <= m_outputs );\n\n for ( auto i = 0u; i < m_inputNames.size(); ++i )\n {\n m_function->setInputName ( i, m_inputNames.at ( i ) );\n }\n\n for ( auto i = 0u; i < m_outputNames.size(); ++i )\n {\n m_function->setOutputName ( i, m_outputNames.at ( i ) );\n }\n }\n\n void initializeInputPorts()\n {\n for ( auto i = 0u; i < m_inputs; ++i )\n {\n m_function->pushInput ( i );\n }\n }\n\n void initializeOutputPorts(bdd_manager_ptr manager)\n {\n auto falseNode = manager->bdd_bot ();\n std::cout << falseNode << std::endl;\n for ( auto i = 0u; i < m_outputs; ++i )\n {\n m_function->setOutputVar ( i, falseNode );\n }\n }\n\n void initializeFunction () {\n assert ( m_inputs != 0 );\n assert ( m_outputs != 0 );\n\n try {\n auto function = new bdd_function (\n m_inputs, m_log_max_objs, m_verbose\n );\n m_function.reset ( function );\n\n initializeInputPorts();\n initializeOutputPorts( m_function->manager() );\n setPortNames();\n }\n catch ( std::exception const& e )\n {\n std::cerr << \"[e] unable to create bdd_function: \" << e.what() << std::endl;\n throw;\n }\n }\n\n void on_cube(const std::string &in, const std::string &out) final\n {\n if ( !m_function ) {\n initializeFunction ();\n }\n\n auto term = getBddCube ( in );\n\n addToOutputBdds ( term, out );\n }\n\n bdd_function_cptr function() const {\n return m_function;\n }\n\n private:\n void addToOutputBdds ( const bdd& term, const std::string& out ) {\n\n auto relevantValue = [] ( const char& val )\n {\n return val == '1';\n };\n\n for ( auto i = 0u; i < out.size(); ++i )\n {\n auto const& value = out.at( i );\n if ( relevantValue ( value ) ) {\n auto output = m_function->lookupOutput ( i );\n// std::cout << \"Output: \" << i << \" is relevant: \" << output << std::endl;\n\n m_function->setOutputVar ( i, output || term );\n }\n }\n }\n\n\n bdd getBddCube ( const std::string& cube )\n {\n auto manager = m_function->manager ();\n\n assert ( cube.size() == m_inputs );\n bdd term = manager->bdd_top ();\n\n for ( auto i = 0u; i < cube.size(); ++i ) {\n auto const& val = cube.at( i );\n\n if ( val != '-') {\n auto input = m_function->lookupInput( i );\n\n if ( val == '0')\n {\n term = !input && term;\n }\n else\n {\n term = input && term;\n }\n }\n }\n\n if ( m_verbose )\n {\n std::cout << \"[i] term result:\" << term << std::endl;\n }\n return term;\n }\n\nprivate:\n unsigned m_log_max_objs;\n bool m_verbose;\n bdd_function_ptr m_function;\n unsigned m_inputs;\n unsigned m_outputs;\n\n boost::timer m_timer;\n\n std::vector m_inputNames;\n std::vector m_outputNames;\n};\n\n} // anonymous namespace\n\n\nbdd_function::bdd_function(\n unsigned nvars\n , unsigned log_max_objs\n , bool verbose\n) : m_manager ( bdd_manager::create ( nvars, log_max_objs, verbose ) )\n{\n}\n\nbdd_function::bdd_function(bdd_manager_ptr manager)\n : m_manager ( manager )\n{\n}\n\nbdd_function::~bdd_function()\n{\n}\n\nvoid bdd_function::pushInput ( unsigned index ) {\n assert ( m_outputs.empty() );\n auto bdd = m_manager->bdd_var( index );\n m_inputs.emplace ( index, bdd );\n}\n\nbdd::const_param_ref bdd_function::lookupInput(unsigned index) const\n{\n auto iter = m_inputs.find ( index );\n assert ( iter != m_inputs.end() );\n return iter->second;\n}\n\nbdd::const_param_ref bdd_function::lookupOutput(unsigned index) const\n{\n auto iter = m_outputs.find ( index );\n assert ( iter != m_outputs.end() );\n return iter->second;\n}\n\nvoid bdd_function::setOutputVar(unsigned index, const bdd &var)\n{\n auto iter = m_outputs.find ( index );\n if ( iter != m_outputs.end() ) {\n iter->second = var;\n }\n else {\n m_outputs.emplace ( index, var );\n }\n}\n\nbdd_manager_ptr bdd_function::manager() const\n{\n return m_manager;\n}\n\nvoid bdd_function::setInputName(unsigned index, const std::string &name)\n{\n m_inputNames.emplace ( index, name );\n}\n\nvoid bdd_function::setOutputName(unsigned index, const std::string &name)\n{\n m_outputNames.emplace ( index, name );\n}\n\nbdd_function_cptr read_pla_into_cirkit_bdd_job( boost::filesystem::ifstream& stream, unsigned log_max_objs, bool verbose )\n{\n assert ( stream );\n\n from_bdd_pla_processor processor ( log_max_objs, verbose );\n try {\n pla_parser ( stream, processor );\n } catch ( std::exception const& e ) {\n std::cerr << \"[e] unable to parse PLA file: \" << e.what() << std::endl;\n return bdd_function_ptr ();\n }\n\n return processor.function();\n}\n\nbdd_function_cptr read_pla_into_cirkit_bdd( const boost::filesystem::path &filename,\n const properties::ptr& settings )\n{\n assert ( !filename.empty() );\n\n auto log_max_objs = get( settings, \"log_max_objs\", 24u );\n auto verbose = get( settings, \"verbose\", false );\n\n boost::filesystem::ifstream stream( filename );\n if ( !stream ) {\n std::cerr << \"[e] unable to open file \" << filename << std::endl;\n return bdd_function_ptr();\n }\n\n return read_pla_into_cirkit_bdd_job( stream, log_max_objs, verbose );\n}\n\nstd::vector bdd_function::input_labels() const { \n std::vector input_vars;\n for (auto const &itr: m_inputNames)\n input_vars.push_back(itr.second);\n return input_vars; \n}\nstd::vector bdd_function::output_labels() const{ \n std::vector output_vars;\n for (auto const &itr: m_outputNames)\n output_vars.push_back(itr.second);\n return output_vars; \n}\n\n} // namespace cirkit\n\n// Local Variables:\n// c-basic-offset: 2\n// eval: (c-set-offset 'substatement-open 0)\n// eval: (c-set-offset 'innamespace 0)\n// End:\n", "meta": {"hexsha": "9ac81324acbf3bb27bb9a14ad81a168a4e5267c8", "size": 8631, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/classical/io/read_pla_to_cirkit_bdd.cpp", "max_stars_repo_name": "eletesta/cirkit", "max_stars_repo_head_hexsha": "6d0939798ea25cecf92306ce796be154139b94f5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/classical/io/read_pla_to_cirkit_bdd.cpp", "max_issues_repo_name": "eletesta/cirkit", "max_issues_repo_head_hexsha": "6d0939798ea25cecf92306ce796be154139b94f5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/classical/io/read_pla_to_cirkit_bdd.cpp", "max_forks_repo_name": "eletesta/cirkit", "max_forks_repo_head_hexsha": "6d0939798ea25cecf92306ce796be154139b94f5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.8731988473, "max_line_length": 122, "alphanum_fraction": 0.6207855405, "num_tokens": 2183, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.665410558746814, "lm_q2_score": 0.523420348936324, "lm_q1q2_score": 0.3482894268451717}} {"text": "/*\n * Copyright (c) 2016 Abhishek Agrawal (abhishek.agrawal@protonmail.com)\n * Distributed under the MIT License.\n * See accompanying file LICENSE.md or copy at http://opensource.org/licenses/MIT\n */\n\n#ifndef PARTICLE_AROUND_SPHEROID_AND_ELLIPSOID_GRAVITATIONAL_POTENTIAL_HPP\n#define PARTICLE_AROUND_SPHEROID_AND_ELLIPSOID_GRAVITATIONAL_POTENTIAL_HPP\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \"NAOS/constants.hpp\"\n#include \"NAOS/basicMath.hpp\"\n#include \"NAOS/basicAstro.hpp\"\n#include \"NAOS/misc.hpp\"\n#include \"NAOS/ellipsoidGravitationalAcceleration.hpp\"\n\nnamespace naos\n{\n//! particle around spheroid integration\n/*!\n * integrate the equations of motion for a particle around a spheroid. The gravitational accelerations\n * calculated using the ellipsoid gravitational potential model.\n */\nvoid executeParticleAroundSpheroid( const double alpha,\n const double gravParameter,\n std::vector< double > asteroidRotationVector,\n std::vector< double > &initialOrbitalElements,\n const double initialStepSize,\n const double startTime,\n const double endTime,\n std::ostringstream &outputFilePath,\n const int dataSaveIntervals );\n} // namespace naos\n\n#endif // PARTICLE_AROUND_SPHEROID_AND_ELLIPSOID_GRAVITATIONAL_POTENTIAL_HPP\n", "meta": {"hexsha": "5572fe6feb097473dfc3ed3902f2fbc54da951d3", "size": 1650, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/NAOS/particleAroundSpheroidAndElllipsoidGravitationalPotential.hpp", "max_stars_repo_name": "agrawalabhishek/NAOS", "max_stars_repo_head_hexsha": "25ae383d2c3f9a52ecd2e06f34661e52e239478b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/NAOS/particleAroundSpheroidAndElllipsoidGravitationalPotential.hpp", "max_issues_repo_name": "agrawalabhishek/NAOS", "max_issues_repo_head_hexsha": "25ae383d2c3f9a52ecd2e06f34661e52e239478b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/NAOS/particleAroundSpheroidAndElllipsoidGravitationalPotential.hpp", "max_forks_repo_name": "agrawalabhishek/NAOS", "max_forks_repo_head_hexsha": "25ae383d2c3f9a52ecd2e06f34661e52e239478b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.8695652174, "max_line_length": 102, "alphanum_fraction": 0.6672727273, "num_tokens": 335, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.665410558746814, "lm_q2_score": 0.5234203489363239, "lm_q1q2_score": 0.34828942684517167}} {"text": "/*\n * Flowlessly\n * Copyright (c) Ionel Gog \n * All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT\n * LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR\n * A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.\n *\n * See the Apache Version 2.0 License for specific language governing\n * permissions and limitations under the License.\n */\n\n#include \"misc/utils.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace flowlessly {\n\nvoid BellmanFord(AdjacencyMapGraph* graph, const set& active_node_ids,\n vector* predecessor) {\n const uint32_t max_node_id = graph->get_max_node_id();\n const auto& arcs = graph->get_arcs();\n auto& nodes = graph->get_nodes();\n vector old_active_ids;\n for (auto& active_node : active_node_ids) {\n nodes[active_node].distance = 0;\n old_active_ids.push_back(active_node);\n }\n for (uint32_t iter = 1;\n iter <= max_node_id && old_active_ids.size();\n ++iter) {\n vector new_active_ids;\n for (auto& node_id : old_active_ids) {\n if (nodes[node_id].distance < numeric_limits::max()) {\n int64_t src_distance = nodes[node_id].distance;\n for (auto& arc : arcs[node_id]) {\n int64_t arc_cost = arc.second->cost -\n nodes[node_id].potential + nodes[arc.first].potential;\n if (arc.second->residual_cap > 0 &&\n src_distance + arc_cost < nodes[arc.first].distance) {\n new_active_ids.push_back(arc.first);\n nodes[arc.first].distance = src_distance + arc_cost;\n (*predecessor)[arc.first] = node_id;\n }\n }\n }\n }\n old_active_ids = new_active_ids;\n }\n}\n\nvoid BellmanFordWithoutPotentials(AdjacencyMapGraph* graph,\n const set& active_node_ids,\n vector* predecessor) {\n const uint32_t max_node_id = graph->get_max_node_id();\n const auto& arcs = graph->get_arcs();\n auto& nodes = graph->get_nodes();\n vector old_active_ids;\n for (auto& active_node : active_node_ids) {\n nodes[active_node].distance = 0;\n old_active_ids.push_back(active_node);\n }\n for (uint32_t iter = 1;\n iter <= max_node_id && old_active_ids.size();\n ++iter) {\n vector new_active_ids;\n for (auto& node_id : old_active_ids) {\n if (nodes[node_id].distance < numeric_limits::max()) {\n int64_t src_distance = nodes[node_id].distance;\n for (auto& arc : arcs[node_id]) {\n if (arc.second->residual_cap > 0 &&\n src_distance + arc.second->cost < nodes[arc.first].distance) {\n new_active_ids.push_back(arc.first);\n nodes[arc.first].distance = src_distance + arc.second->cost;\n (*predecessor)[arc.first] = node_id;\n }\n }\n }\n }\n old_active_ids = new_active_ids;\n }\n}\n\nuint32_t DijkstraOptimized(AdjacencyMapGraph* graph,\n const set& active_node_ids,\n vector* predecessor) {\n const uint32_t max_node_id = graph->get_max_node_id();\n const auto& arcs = graph->get_arcs();\n auto& nodes = graph->get_nodes();\n boost::heap::binomial_heap,\n boost::heap::compare > > > dist_heap;\n // Handles to the heap elements.\n boost::heap::binomial_heap,\n boost::heap::compare > > >::handle_type\n *handles =\n new boost::heap::binomial_heap,\n boost::heap::compare > > >::handle_type[max_node_id + 1];\n // ASSUMPTION: Works with the assumption that all the elements of distance are\n // already set to INF.\n for (auto& active_node : active_node_ids) {\n nodes[active_node].distance = 0;\n nodes[active_node].status = VISITING;\n handles[active_node] = dist_heap.push(make_pair(0, active_node));\n }\n while (dist_heap.size() > 0) {\n uint32_t min_node_id = dist_heap.top().second;\n // CHECK_LE(min_node_id, max_node_id);\n dist_heap.pop();\n nodes[min_node_id].status = VISITED;\n // We've finished visiting a node with negative supply. We can stop the\n // shortest path algorithm because we want to route flow to this node.\n if (nodes[min_node_id].supply < 0) {\n delete [] handles;\n return min_node_id;\n }\n int64_t src_distance = nodes[min_node_id].distance;\n for (auto& arc : arcs[min_node_id]) {\n int64_t arc_cost = arc.second->cost - nodes[min_node_id].potential +\n nodes[arc.first].potential;\n if (arc.second->residual_cap > 0 &&\n src_distance + arc_cost < nodes[arc.first].distance) {\n nodes[arc.first].distance = src_distance + arc_cost;\n if (nodes[arc.first].status == NOT_VISITED) {\n // The node's status is set to VISITING the first time we've computed\n // its distance. On this ocassion we also get a handle to the node's\n // entry in the binomial heap.\n nodes[arc.first].status = VISITING;\n (*predecessor)[arc.first] = min_node_id;\n handles[arc.first] =\n dist_heap.push(make_pair(nodes[arc.first].distance, arc.first));\n } else {\n (*predecessor)[arc.first] = min_node_id;\n dist_heap.update(handles[arc.first],\n make_pair(nodes[arc.first].distance, arc.first));\n }\n }\n }\n }\n delete [] handles;\n // 0 means that no node has been found.\n return 0;\n}\n\nvoid DijkstraSimple(AdjacencyMapGraph* graph,\n const set& active_node_ids,\n vector* predecessor) {\n const uint32_t max_node_id = graph->get_max_node_id();\n const auto& arcs = graph->get_arcs();\n auto& nodes = graph->get_nodes();\n vector node_used(max_node_id + 1, false);\n // ASSUMPTION: Works with the assumption that all the elements of distance are\n // already set to INF.\n for (auto& active_node : active_node_ids) {\n nodes[active_node].distance = 0;\n }\n for (uint32_t iter = 1; iter <= max_node_id; ++iter) {\n int64_t min_node_distance = numeric_limits::max();\n uint32_t min_node_id = 0;\n // Get the closest unused vertex.\n for (uint32_t node_id = 1; node_id <= max_node_id; ++node_id) {\n if (!node_used[node_id] && nodes[node_id].distance < min_node_distance) {\n min_node_distance = nodes[node_id].distance;\n min_node_id = node_id;\n }\n }\n node_used[min_node_id] = true;\n for (auto& arc : arcs[min_node_id]) {\n int64_t arc_cost = arc.second->cost -\n nodes[min_node_id].potential + nodes[arc.first].potential;\n if (arc.second->residual_cap > 0 && nodes[min_node_id].distance +\n arc_cost < nodes[arc.first].distance) {\n nodes[arc.first].distance = nodes[min_node_id].distance + arc_cost;\n (*predecessor)[arc.first] = min_node_id;\n }\n }\n }\n}\n\n// Computes max flow over the graph using the Ford-Fulkerson algorithm.\n// The Complexity of the algorithm is O(E * F). Where F is the max flow value.\n// NOTE: This method changes the graph.\nvoid MaxFlow(AdjacencyMapGraph* graph) {\n const uint32_t max_node_id = graph->get_max_node_id();\n vector >& arcs = graph->get_arcs();\n vector& nodes = graph->get_nodes();\n vector visited(max_node_id + 1, 0);\n vector predecessor(max_node_id + 1, 0);\n set& active_node_ids = graph->get_active_node_ids();\n uint32_t sink_node = graph->get_sink_node();\n bool has_path = true;\n while (has_path) {\n has_path = false;\n queue to_visit;\n fill(visited.begin(), visited.end(), 0);\n fill(predecessor.begin(), predecessor.end(), 0);\n for (const auto& active_node : active_node_ids) {\n if (nodes[active_node].supply > 0) {\n to_visit.push(active_node);\n visited[active_node] = nodes[active_node].supply;\n break;\n }\n }\n while (!to_visit.empty() && !has_path) {\n uint32_t cur_node = to_visit.front();\n to_visit.pop();\n for (auto& arc : arcs[cur_node]) {\n if (!visited[arc.first] && arc.second->residual_cap > 0) {\n visited[arc.first] = min(arc.second->residual_cap, visited[cur_node]);\n to_visit.push(arc.first);\n predecessor[arc.first] = cur_node;\n if (arc.first == sink_node) {\n has_path = true;\n int32_t min_aux_flow = visited[arc.first];\n for (uint32_t cur_node = arc.first; predecessor[cur_node] > 0;\n cur_node = predecessor[cur_node]) {\n Arc* cur_arc = arcs[predecessor[cur_node]][cur_node];\n cur_arc->residual_cap -= min_aux_flow;\n cur_arc->reverse_arc->residual_cap += min_aux_flow;\n nodes[predecessor[cur_node]].supply -= min_aux_flow;\n nodes[cur_node].supply += min_aux_flow;\n }\n break;\n }\n }\n }\n }\n }\n // Check that all the supply has been drained.\n for (auto& active_node : active_node_ids) {\n CHECK_EQ(nodes[active_node].supply, 0);\n }\n // NOTE: The method does not update the set of active nodes because\n // the nodes are used in the CycleCancelling algorithm as starting\n // nodes for the BellmanFord algorithm. However, the active_node_ids\n // are cleared at the end of the of CycleCancelling.\n}\n\nvoid ReverseMaxFlow(AdjacencyMapGraph* graph) {\n const uint32_t max_node_id = graph->get_max_node_id();\n auto& admissible_arcs = graph->get_admissible_arcs();\n auto& arcs = graph->get_arcs();\n vector& nodes = graph->get_nodes();\n vector visited(max_node_id + 1, 0);\n vector predecessor(max_node_id + 1, 0);\n uint32_t sink_node = graph->get_sink_node();\n set demand_node_ids;\n for (uint32_t node_id = 1; node_id <= max_node_id; ++node_id) {\n if (nodes[node_id].supply < 0 && node_id != sink_node) {\n demand_node_ids.insert(node_id);\n }\n }\n bool has_path = true;\n while (has_path) {\n has_path = false;\n queue to_visit;\n fill(visited.begin(), visited.end(), 0);\n fill(predecessor.begin(), predecessor.end(), 0);\n for (const auto& demand_node : demand_node_ids) {\n if (nodes[demand_node].supply < 0 && demand_node != sink_node) {\n to_visit.push(demand_node);\n visited[demand_node] = -nodes[demand_node].supply;\n break;\n }\n }\n while (!to_visit.empty() && !has_path) {\n uint32_t cur_node = to_visit.front();\n to_visit.pop();\n for (auto& arc : arcs[cur_node]) {\n if (!visited[arc.first] && arc.second->reverse_arc->residual_cap > 0) {\n visited[arc.first] = min(arc.second->reverse_arc->residual_cap,\n visited[cur_node]);\n to_visit.push(arc.first);\n predecessor[arc.first] = cur_node;\n if (arc.first == sink_node) {\n has_path = true;\n int32_t min_aux_flow = visited[arc.first];\n for (uint32_t cur_node = arc.first; predecessor[cur_node] > 0;\n cur_node = predecessor[cur_node]) {\n Arc* cur_arc = arcs[predecessor[cur_node]][cur_node];\n cur_arc->residual_cap += min_aux_flow;\n // Add the arc back to the admissible graph.\n admissible_arcs[cur_arc->src_node_id][cur_arc->dst_node_id] =\n cur_arc;\n cur_arc->reverse_arc->residual_cap -= min_aux_flow;\n nodes[predecessor[cur_node]].supply += min_aux_flow;\n nodes[cur_node].supply -= min_aux_flow;\n }\n break;\n }\n }\n }\n }\n }\n}\n\n} // namespace flowlessly\n", "meta": {"hexsha": "16b6dcf161fbf2cc2a3b386ffadfceffe3945be5", "size": 12298, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/misc/utils.cc", "max_stars_repo_name": "mitake/Flowlessly", "max_stars_repo_head_hexsha": "fc130276ae9ceb2550f8885ba89f2edeccfddb94", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 10.0, "max_stars_repo_stars_event_min_datetime": "2016-06-11T23:54:57.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-10T01:59:47.000Z", "max_issues_repo_path": "src/misc/utils.cc", "max_issues_repo_name": "mitake/Flowlessly", "max_issues_repo_head_hexsha": "fc130276ae9ceb2550f8885ba89f2edeccfddb94", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-06-05T16:40:16.000Z", "max_issues_repo_issues_event_max_datetime": "2018-08-30T07:04:37.000Z", "max_forks_repo_path": "src/misc/utils.cc", "max_forks_repo_name": "mitake/Flowlessly", "max_forks_repo_head_hexsha": "fc130276ae9ceb2550f8885ba89f2edeccfddb94", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2016-07-30T23:51:11.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-16T04:52:52.000Z", "avg_line_length": 39.2907348243, "max_line_length": 80, "alphanum_fraction": 0.6333550171, "num_tokens": 3110, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6370307806984444, "lm_q2_score": 0.5467381519846138, "lm_q1q2_score": 0.3482890317963833}} {"text": "// This file is part of LatNet Builder.\n//\n// Copyright (C) 2012-2021 The LatNet Builder author's, supervised by Pierre L'Ecuyer, Universite de Montreal.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n#include \"latbuilder/Norm/IAAlpha.h\"\n#include \"latbuilder/WeightsDispatcher.h\"\n#include \"latbuilder/Util.h\"\n\n#include \n#include \n#include \n\nnamespace LatBuilder { namespace Norm {\n \n typedef boost::math::tools::polynomial RealPolynomial;\n\nnamespace SumHelperIAAlpha{\n\n\n template \n struct SumHelper {\n Real operator()(\n const WEIGHTS& weights,\n Real lambda,\n Dimension dimension,\n unsigned int alpha\n ) const\n {\n throw std::runtime_error(\"IAAlpha normalization not implemented for these weights.\");\n return 1.;\n }\n };\n\n\n#define DECLARE_IAALPHA_SUM(weight_type) \\\n template <> \\\n class SumHelper { \\\n public: \\\n Real operator()( \\\n const weight_type& weights, \\\n Real lambda, \\\n Dimension dimension, \\\n unsigned int alpha \\\n ) const; \\\n }\\\n\n DECLARE_IAALPHA_SUM(LatBuilder::CombinedWeights);\n DECLARE_IAALPHA_SUM(LatBuilder::Interlaced::IPODWeights);\n DECLARE_IAALPHA_SUM(LatBuilder::Interlaced::IPDWeights);\n\n#undef DECLARE_IAALPHA_SUM\n\n //===========================================================================\n // combined weights\n //===========================================================================\n\n // Separating sumCombined() from\n // SumHelper::operator() is a workaround for\n // LLVM/clang++.\n Real sumCombined(\n const CombinedWeights& weights,\n Real lambda,\n Dimension dimension,\n unsigned int alpha\n )\n {\n Real val = 0.0;\n for (const auto& w : weights.list())\n val += WeightsDispatcher::dispatch(*w, lambda, dimension, alpha);\n return val;\n }\n\n Real SumHelper::operator()(\n const CombinedWeights& weights,\n Real lambda,\n Dimension dimension,\n unsigned int alpha\n ) const\n {\n return sumCombined(weights, lambda, dimension, alpha);\n }\n\n\n //===========================================================================\n // interlaced projection-dependent weights\n //===========================================================================\n\n Real SumHelper>::operator()(\n const LatBuilder::Interlaced::IPDWeights& weights,\n Real lambda,\n Dimension dimension,\n unsigned int alpha\n ) const\n { \n unsigned int interlacingFactor = weights.interlacingFactor();\n Dimension j0 = (Dimension) std::ceil( (double) dimension / interlacingFactor);\n Dimension d0 = dimension - (j0 - 1) * interlacingFactor;\n Real gTilde = 1 / (pow(2.0, alpha*lambda/2)) * std::max(pow(intPow(2.0,std::min(alpha, interlacingFactor))-2,-lambda), 1 / (pow(2.0, lambda * std::min(alpha, interlacingFactor)) - 2));\n Real g = - 1.0 + intPow(1 + gTilde, interlacingFactor);\n Real g0 = - 1.0 + intPow(1 + gTilde, d0);\n Real val = 0.0;\n for (Dimension largestIndex = 0; largestIndex < j0; largestIndex++) {\n // iterate only through projections that have a weight\n for (const auto& pw : weights.getBaseWeights().getWeightsForLargestIndex(largestIndex)) {\n const auto& proj = pw.first;\n const auto& weight = pw.second;\n if (weight)\n {\n if (largestIndex < j0 - 1)\n {\n val += pow(weight, lambda) * intPow(g, proj.size());\n }\n else\n {\n val += pow(weight, lambda) * g0 * intPow(g, proj.size() - 1);\n }\n }\n }\n }\n\n return val;\n }\n\n //===========================================================================\n // IPOD weights\n //===========================================================================\n \n Real SumHelper>::operator()(\n const LatBuilder::Interlaced::IPODWeights& weights,\n Real lambda,\n Dimension dimension,\n unsigned int alpha\n ) const\n {\n unsigned int interlacingFactor = weights.interlacingFactor();\n Dimension j0 = (Dimension) std::ceil( (double) dimension / interlacingFactor);\n Dimension d0 = dimension - (j0 - 1) * interlacingFactor;\n Real gTilde = 1 / (pow(2.0, alpha*lambda/2)) * std::max(pow(intPow(2.0,std::min(alpha, interlacingFactor))-2,-lambda), 1 / (pow(2.0, lambda * std::min(alpha, interlacingFactor)) - 2));\n Real g = - 1.0 + intPow(1 + gTilde, interlacingFactor);\n Real g0 = - 1.0 + intPow(1 + gTilde, d0);\n\n Real val = g0 * pow(weights.getWeightForCoordinate(j0 - 1) * weights.getWeightForOrder(1), lambda);\n RealPolynomial acc{1.0};\n for(Dimension coord = 0; coord < j0 - 1; ++coord)\n {\n acc *= RealPolynomial{{pow(weights.getWeightForCoordinate(coord), lambda) * g, 1.0}};\n }\n for(Dimension degree = 0; degree < j0 - 1; ++degree)\n {\n val += acc[degree] * (pow(weights.getWeightForOrder(j0 - 1 - degree),lambda) + g0 * pow(weights.getWeightForCoordinate(j0 - 1) * weights.getWeightForOrder(j0 - degree), lambda)) ;\n }\n return val;\n }\n\n}\n\nIAAlpha::IAAlpha(unsigned int alpha, const LatticeTester::Weights& weights, Real normType):\n NormAlphaBase(alpha, normType),\n m_weights(weights)\n{}\n\ntemplate \nReal IAAlpha::value(\n Real lambda,\n const SizeParam& sizeParam,\n Dimension dimension,\n Real norm\n ) const\n{\n norm = 1.0 / (norm * (sizeParam.numPoints() - 1.0));\n Real val = WeightsDispatcher::dispatch(\n m_weights,\n lambda,\n dimension,\n alpha()\n );\n\n return pow(val * norm, 1.0 / lambda);\n}\n\ntemplate Real IAAlpha::value(Real, const SizeParam&, Dimension, Real) const;\ntemplate Real IAAlpha::value(Real, const SizeParam&, Dimension, Real) const;\n\ntemplate Real IAAlpha::value(Real, const SizeParam&, Dimension, Real) const;\ntemplate Real IAAlpha::value(Real, const SizeParam&, Dimension, Real) const;\n\n}}\n", "meta": {"hexsha": "05d902b583dd174e70d25cfa66e5b17ef30fbf82", "size": 7595, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/LatBuilder/Norm/IAAlpha.cc", "max_stars_repo_name": "YochevedDarmon/latnetbuilder", "max_stars_repo_head_hexsha": "7df3a7ba89e10ca51d4af347b75cdb0987e5151c", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 10.0, "max_stars_repo_stars_event_min_datetime": "2020-01-21T06:08:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-24T16:11:31.000Z", "max_issues_repo_path": "src/LatBuilder/Norm/IAAlpha.cc", "max_issues_repo_name": "YochevedDarmon/latnetbuilder", "max_issues_repo_head_hexsha": "7df3a7ba89e10ca51d4af347b75cdb0987e5151c", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2019-10-31T07:49:28.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-03T12:07:49.000Z", "max_forks_repo_path": "src/LatBuilder/Norm/IAAlpha.cc", "max_forks_repo_name": "YochevedDarmon/latnetbuilder", "max_forks_repo_head_hexsha": "7df3a7ba89e10ca51d4af347b75cdb0987e5151c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2016-07-27T19:25:26.000Z", "max_forks_repo_forks_event_max_datetime": "2018-05-22T20:00:47.000Z", "avg_line_length": 37.975, "max_line_length": 191, "alphanum_fraction": 0.5980250165, "num_tokens": 1840, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7248702761768248, "lm_q2_score": 0.48047867804790706, "lm_q1q2_score": 0.34828471205366207}} {"text": "/**\n * Creates needed tables\n * @author Tobias Weber \n * @date nov-2015\n * @license GPLv2\n */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"tlibs/string/string.h\"\n#include \"tlibs/file/prop.h\"\n#include \"tlibs/log/log.h\"\n#include \"tlibs/math/linalg.h\"\n#include \"libs/spacegroups/sghelper.h\"\n#ifndef NO_CLP\n\t#include \"libs/spacegroups/spacegroup_clp.h\"\n#endif\n\n#ifndef USE_BOOST_REX\n\t#include \n\tnamespace rex = ::std;\n#else\n\t#include \n\tnamespace rex = ::boost;\n#endif\n\n#include \n#include \n\nnamespace prop = boost::property_tree;\nnamespace algo = boost::algorithm;\nnamespace ublas = boost::numeric::ublas;\n\nusing t_real = double;\nusing t_cplx = std::complex;\nusing t_mat = ublas::matrix;\n\n\nunsigned g_iPrec = std::numeric_limits::max_digits10-1;\n\n// ============================================================================\n\n#include \"gentab_web.cpp\"\n#ifndef NO_CLP\n\t#include \"gentab_clp.cpp\"\n#endif\n\n// ============================================================================\n\n\nstatic std::unordered_map g_mapElems;\n\n/**\n * periodic table of elements\n */\nbool gen_elements()\n{\n\tg_mapElems.clear();\n\n\tusing t_propval = tl::Prop::t_propval;\n\n\ttl::Prop propIn, propOut;\n\tpropIn.SetSeparator('/');\n\tpropOut.SetSeparator('.');\n\n\tif(!propIn.Load(\"tmp/elements.xml\", tl::PropType::XML))\n\t{\n\t\ttl::log_err(\"Cannot load periodic table of elements \\\"tmp/elements.xml\\\".\");\n\t\treturn false;\n\t}\n\n\n\t// iterate over all elements\n\tstd::vector vecElems = propIn.GetFullChildNodes(\"/list\");\n\tstd::size_t iElem = 0;\n\tfor(const t_propval& elem : vecElems)\n\t{\n\t\tif(elem.first != \"atom\") continue;\n\n\t\ttry\n\t\t{\n\t\t\ttl::Prop propelem(elem.second, '/');\n\n\t\t\tstd::string strName = propelem.Query(\"/id\", \"\");\n\t\t\tif(strName == \"\" || strName == \"Xx\") continue;\n\n\t\t\tt_real dMass = t_real(-1);\n\t\t\tt_real dRadCov=t_real(-1), dRadVdW=t_real(-1);\n\t\t\tt_real dEIon=t_real(-1), dEAffin(-1);\n\t\t\tt_real dTMelt=t_real(-1), dTBoil=t_real(-1);\n\t\t\tint iNr=-1, iPeriod=-1, iGroup=-1;\n\t\t\tstd::string strConfig, strBlock;\n\n\t\t\t// iterate over all properties\n\t\t\tfor(auto iterVal=propelem.GetProp().begin(); iterVal!=propelem.GetProp().end(); ++iterVal)\n\t\t\t{\n\t\t\t\ttl::Prop propVal(iterVal->second, '/');\n\t\t\t\tstd::string strKey = propVal.Query(\"/dictRef\", \"\");\n\t\t\t\tstd::string strVal = propVal.Query(\"/\", \"\");\n\t\t\t\t//std::cout << strKey << \" = \" << strVal << std::endl;\n\n\t\t\t\tif(strKey.find(\"atomicNumber\") != std::string::npos)\n\t\t\t\t\tiNr = tl::str_to_var(strVal);\n\t\t\t\telse if(strKey.find(\"electronicConfiguration\") != std::string::npos)\n\t\t\t\t\tstrConfig = strVal;\n\t\t\t\telse if(strKey.find(\"periodTableBlock\") != std::string::npos)\n\t\t\t\t\tstrBlock = strVal;\n\t\t\t\telse if(strKey.find(\"period\") != std::string::npos)\n\t\t\t\t\tiPeriod = tl::str_to_var(strVal);\n\t\t\t\telse if(strKey.find(\"group\") != std::string::npos)\n\t\t\t\t\tiGroup = tl::str_to_var(strVal);\n\t\t\t\telse if(strKey.find(\"exactMass\") != std::string::npos)\n\t\t\t\t\tdMass = tl::str_to_var(strVal);\n\t\t\t\telse if(strKey.find(\"radiusCovalent\") != std::string::npos)\n\t\t\t\t\tdRadCov = tl::str_to_var(strVal);\n\t\t\t\telse if(strKey.find(\"radiusVDW\") != std::string::npos)\n\t\t\t\t\tdRadVdW = tl::str_to_var(strVal);\n\t\t\t\telse if(strKey.find(\"ionization\") != std::string::npos)\n\t\t\t\t\tdEIon = tl::str_to_var(strVal);\n\t\t\t\telse if(strKey.find(\"electronAffinity\") != std::string::npos)\n\t\t\t\t\tdEAffin = tl::str_to_var(strVal);\n\t\t\t\telse if(strKey.find(\"melting\") != std::string::npos)\n\t\t\t\t\tdTMelt = tl::str_to_var(strVal);\n\t\t\t\telse if(strKey.find(\"boiling\") != std::string::npos)\n\t\t\t\t\tdTBoil = tl::str_to_var(strVal);\n\t\t\t}\n\n\t\t\tstd::ostringstream ostr;\n\t\t\tostr << \"pte.elem_\" << iElem;\n\t\t\tstd::string strElem = ostr.str();\n\n\t\t\tpropOut.Add(strElem + \".name\", strName);\n\t\t\tpropOut.Add(strElem + \".num\", tl::var_to_str(iNr, g_iPrec));\n\t\t\tpropOut.Add(strElem + \".period\", tl::var_to_str(iPeriod, g_iPrec));\n\t\t\tpropOut.Add(strElem + \".group\", tl::var_to_str(iGroup, g_iPrec));\n\t\t\tpropOut.Add(strElem + \".orbitals\", strConfig);\n\t\t\tpropOut.Add(strElem + \".block\", strBlock);\n\t\t\tpropOut.Add(strElem + \".m\", tl::var_to_str(dMass, g_iPrec));\n\t\t\tpropOut.Add(strElem + \".r_cov\", tl::var_to_str(dRadCov, g_iPrec));\n\t\t\tpropOut.Add(strElem + \".r_vdW\", tl::var_to_str(dRadVdW, g_iPrec));\n\t\t\tpropOut.Add(strElem + \".E_ion\", tl::var_to_str(dEIon, g_iPrec));\n\t\t\tpropOut.Add(strElem + \".E_affin\", tl::var_to_str(dEAffin, g_iPrec));\n\t\t\tpropOut.Add(strElem + \".T_melt\", tl::var_to_str(dTMelt, g_iPrec));\n\t\t\tpropOut.Add(strElem + \".T_boil\", tl::var_to_str(dTBoil, g_iPrec));\n\n\t\t\tg_mapElems[strName] = iNr;\n\t\t}\n\t\tcatch(const std::exception& ex)\n\t\t{\n\t\t\ttl::log_err(\"Element \", iElem, \": \", ex.what());\n\t\t}\n\n\t\t++iElem;\n\t}\n\n\n\tpropOut.Add(\"pte.num_elems\", iElem);\n\n\tpropOut.Add(\"pte.source\", \"Periodic table of the elements obtained from the \"\n\t\t\"Blue Obelisk Data Repository.\");\n\tpropOut.Add(\"pte.source_url\", \"https://github.com/egonw/bodr/blob/master/bodr/elements/elements.xml\");\n\n\tif(!propOut.Save(\"res/data/elements.xml.gz\"))\n\t{\n\t\ttl::log_err(\"Cannot write \\\"res/data/elements.xml.gz\\\".\");\n\t\treturn false;\n\t}\n\n\treturn true;\n}\n\n\n\n// ============================================================================\n\n\n/**\n * space groups (alternative)\n */\nbool gen_spacegroups()\n{\n\tusing t_propval = tl::Prop::t_propval;\n\n\ttl::Prop propIn, propOut;\n\tpropIn.SetSeparator('/');\n\tpropOut.SetSeparator('.');\n\n\tif(!propIn.Load(\"tmp/space-groups.xml\", tl::PropType::XML))\n\t{\n\t\ttl::log_err(\"Cannot load space group table \\\"tmp/space-groups.xml\\\".\");\n\t\treturn false;\n\t}\n\n\n\t// iterate over all groups\n\tstd::vector vecGroups = propIn.GetFullChildNodes(\"/list\");\n\tstd::size_t iGroup = 0;\n\tstd::set setNames;\n\tfor(const t_propval& grp : vecGroups)\n\t{\n\t\tif(grp.first != \"group\") continue;\n\n\t\ttry\n\t\t{\n\t\t\ttl::Prop propgrp(grp.second, '/');\n\n\t\t\tstd::string strId = propgrp.Query(\"/id\", \"\");\n\t\t\tif(strId == \"\") continue;\n\t\t\tint iNr = tl::str_to_var(strId);\n\n\t\t\tstd::string strName = propgrp.Query(\"/HM\", \"\");\n\t\t\tif(strName == \"\") continue;\n\t\t\ttl::find_all_and_replace(strName, \":1\", \"\");\n\t\t\ttl::find_all_and_replace(strName, \":2\", \"\");\n\t\t\ttl::find_all_and_replace(strName, \":3\", \"\");\n\t\t\txtl::convert_hm_symbol(strName);\n\n\t\t\t// find an unique name\n\t\t\tstd::size_t iNameCtr = 1;\n\t\t\twhile(1)\n\t\t\t{\n\t\t\t\tstd::ostringstream ostrNewName;\n\t\t\t\tostrNewName << strName;\n\t\t\t\tif(iNameCtr >= 2)\n\t\t\t\t\tostrNewName << \" [\" << iNameCtr << \"]\";\n\t\t\t\tif(setNames.find(ostrNewName.str()) == setNames.end())\n\t\t\t\t{\n\t\t\t\t\tstrName = ostrNewName.str();\n\t\t\t\t\tsetNames.insert(strName);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\t++iNameCtr;\n\t\t\t}\n\n\t\t\tstd::ostringstream ostr;\n\t\t\tostr << \"sgroups.group_\" << iGroup;\n\t\t\tstd::string strGroup = ostr.str();\n\n\t\t\tstd::vector vecTrafos = propgrp.GetFullChildNodes(\"/\");\n\t\t\tstd::size_t iTrafo = 0;\n\t\t\tfor(const t_propval& trafo : vecTrafos)\n\t\t\t{\n\t\t\t\tif(trafo.first != \"transform\") continue;\n\n\t\t\t\ttl::Prop proptrafo(trafo.second, '/');\n\t\t\t\tstd::string strTrafo = proptrafo.Query(\"/\", \"\");\n\n\t\t\t\tstd::ostringstream ostrTrafo;\n\t\t\t\tostrTrafo << strGroup << \".trafo_\" << iTrafo;\n\t\t\t\tstd::string strTrafoKey = ostrTrafo.str();\n\n\t\t\t\tt_mat matTrafo = xtl::get_desc_trafo(strTrafo);\n\t\t\t\tstd::string strAttribs = \"; \";\n\t\t\t\tif(tl::is_identity_matrix(matTrafo) ||\n\t\t\t\t\ttl::is_inverting_matrix(tl::submatrix(matTrafo,3,3)))\n\t\t\t\t\tstrAttribs += \"i\";\n\t\t\t\tif(tl::is_identity_matrix(matTrafo) ||\n\t\t\t\t\ttl::is_centering_matrix(matTrafo))\n\t\t\t\t\tstrAttribs += \"c\";\n\t\t\t\t/*if(tl::is_identity_matrix(matTrafo) ||\n\t\t\t\t\t(tl::has_translation_components(matTrafo) &&\n\t\t\t\t\t\t!tl::is_centering_matrix(matTrafo) &&\n\t\t\t\t\t\t!tl::is_inverting_matrix(tl::submatrix(matTrafo,3,3))))\n\t\t\t\t\tstrAttribs += \"s\";*/\n\t\t\t\tif(tl::is_identity_matrix(matTrafo) ||\n\t\t\t\t\ttl::has_translation_components(matTrafo))\n\t\t\t\t\tstrAttribs += \"t\";\n\n\t\t\t\tpropOut.Add(strTrafoKey, tl::var_to_str(matTrafo, g_iPrec) + strAttribs);\n\t\t\t\t++iTrafo;\n\t\t\t}\n\n\t\t\tpropOut.Add(strGroup + \".number\", tl::var_to_str(iNr, g_iPrec));\n\t\t\tpropOut.Add(strGroup + \".name\", strName);\n\t\t\tpropOut.Add(strGroup + \".num_trafos\", tl::var_to_str(iTrafo, g_iPrec));\n\t\t}\n\t\tcatch(const std::exception& ex)\n\t\t{\n\t\t\ttl::log_err(\"Space group \", iGroup, \": \", ex.what());\n\t\t}\n\n\t\t++iGroup;\n\t}\n\n\n\tpropOut.Add(\"sgroups.num_groups\", iGroup);\n\n\tpropOut.Add(\"sgroups.source\", \"Space groups obtained from the \"\n\t\t\"Blue Obelisk Data Repository.\");\n\tpropOut.Add(\"sgroups.source_url\", \"https://github.com/egonw/bodr/blob/master/bodr/crystal/space-groups.xml\");\n\n\tif(!propOut.Save(\"res/data/sgroups.xml.gz\"))\n\t{\n\t\ttl::log_err(\"Cannot write \\\"res/data/sgroups.xml.gz\\\".\");\n\t\treturn false;\n\t}\n\n\treturn true;\n}\n\n\n\n// ============================================================================\n\n\nstruct ffact\n{\n\tstd::string strName;\n\n\tt_cplx cCohb, cIncb;\n\n\tt_real dScatXs, dAbsXs;\n\tt_real dCohXs, dIncXs;\n\n\tbool bIncCohXs = 0;\n\tbool bIncIncXs = 0;\n\tbool bIncScatXs = 0;\n\n\tstd::string strAbund;\n\tt_real dAbOrHL;\n\tbool bAb;\n};\n\nbool gen_scatlens_npy()\n{\n\ttl::Prop propIn, propOut;\n\tpropIn.SetSeparator('/');\n\tpropOut.SetSeparator('.');\n\n\tif(!propIn.Load(\"tmp/scattering_lengths.json\", tl::PropType::JSON))\n\t{\n\t\ttl::log_err(\"Cannot load scattering length table \\\"tmp/scattering_lengths.json\\\".\");\n\t\treturn false;\n\t}\n\n\tstd::vector vecNuclei = propIn.GetChildNodes(\"/\");\n\tstd::vector vecFfacts;\n\n\tfor(const std::string& strNucl : vecNuclei)\n\t{\n\t\tffact ff;\n\n\t\tff.strName = strNucl;\n\t\tff.cCohb = propIn.Query(\"/\" + strNucl + \"/Coh b\");\n\t\tff.cIncb = propIn.Query(\"/\" + strNucl + \"/Inc b\");\n\t\tff.dAbsXs = propIn.Query(\"/\" + strNucl + \"/Abs xs\") * t_real(100); // in fm^2\n\t\tff.dCohXs = propIn.Query(\"/\" + strNucl + \"/Coh xs\") * t_real(100);\n\t\tff.dIncXs = propIn.Query(\"/\" + strNucl + \"/Inc xs\") * t_real(100);\n\t\tff.dScatXs = propIn.Query(\"/\" + strNucl + \"/Scatt xs\");\n\t\tff.strAbund = propIn.Query(\"/\" + strNucl + \"/conc\");\n\n\t\t// include total scattering cross-section only if it is not the sum\n\t\t// of the coherent and incoherent cross-sections\n\t\tif(!tl::float_equal(ff.dScatXs, ff.dCohXs + ff.dIncXs, 1.))\n\t\t{\n\t\t\tff.bIncScatXs = 1;\n\t\t\t//tl::log_warn(\"Mismatch in scattering cross-section for \", ff.strName, \": \",\n\t\t\t//\tff.dCohXs + ff.dIncXs, \" != \", ff.dScatXs, \".\");\n\t\t}\n\n\t\tif(!tl::float_equal(ff.dCohXs, (ff.cCohb*std::conj(ff.cCohb)).real()*t_real(4)*tl::get_pi(), 1.))\n\t\t{\n\t\t\tff.bIncCohXs = 1;\n\t\t\t//tl::log_warn(\"Mismatch in coherent cross-section for \", ff.strName, \": \",\n\t\t\t//\t(ff.cCohb*std::conj(ff.cCohb)).real()*t_real(4)*tl::get_pi(),\n\t\t\t//\t\" != \", ff.dCohXs, \".\");\n\t\t}\n\n\t\tif(!tl::float_equal(ff.dIncXs, (ff.cIncb*std::conj(ff.cIncb)).real()*t_real(4)*tl::get_pi(), 1.))\n\t\t{\n\t\t\tff.bIncIncXs = 1;\n\t\t\t//tl::log_warn(\"Mismatch in incoherent cross-section for \", ff.strName, \": \",\n\t\t\t//\t(ff.cIncb*std::conj(ff.cIncb)).real()*t_real(4)*tl::get_pi(),\n\t\t\t//\t\" != \", ff.dIncXs, \".\");\n\t\t}\n\n\n\t\t// complex?\n\t\tauto vecValsCohb = propIn.GetChildValues(\"/\" + strNucl + \"/Coh b\");\n\t\tauto vecValsIncb = propIn.GetChildValues(\"/\" + strNucl + \"/Inc b\");\n\n\t\tif(vecValsCohb.size() >= 2)\n\t\t{\n\t\t\tff.cCohb.real(vecValsCohb[0]);\n\t\t\tff.cCohb.imag(vecValsCohb[1]);\n\t\t}\n\t\tif(vecValsIncb.size() >= 2)\n\t\t{\n\t\t\tff.cIncb.real(vecValsIncb[0]);\n\t\t\tff.cIncb.imag(vecValsIncb[1]);\n\t\t}\n\n\t\tff.dAbOrHL = t_real(0);\n\t\tff.bAb = get_abundance_or_hl(ff.strAbund, ff.dAbOrHL);\n\n\t\tvecFfacts.emplace_back(std::move(ff));\n\t}\n\n\n\t// sort elements if elements map is not empty\n\tif(g_mapElems.size())\n\t{\n\t\tstd::stable_sort(vecFfacts.begin(), vecFfacts.end(),\n\t\t\t[](const ffact& ff1, const ffact& ff2) -> bool\n\t\t\t{\n\t\t\t\tstd::string strName1 = tl::remove_chars(ff1.strName, std::string(\"+-0123456789\"));\n\t\t\t\tstd::string strName2 = tl::remove_chars(ff2.strName, std::string(\"+-0123456789\"));\n\n\t\t\t\tauto iter1 = g_mapElems.find(strName1);\n\t\t\t\tauto iter2 = g_mapElems.find(strName2);\n\n\t\t\t\tif(iter1 == g_mapElems.end())\n\t\t\t\t{\n\t\t\t\t\ttl::log_err(\"Element \", strName1, \" not in table!\");\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\t\t\t\tif(iter2 == g_mapElems.end())\n\t\t\t\t{\n\t\t\t\t\ttl::log_err(\"Element \", strName2, \" not in table!\");\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\n\t\t\t\treturn iter1->second < iter2->second;\n\t\t\t});\n\t}\n\n\n\t// write database\n\tstd::size_t iNucl = 0;\n\tfor(const ffact& ff : vecFfacts)\n\t{\n\t\tstd::ostringstream ostr;\n\t\tostr << \"scatlens.atom_\" << iNucl;\n\t\tstd::string strAtom = ostr.str();\n\n\t\tpropOut.Add(strAtom + \".name\", ff.strName);\n\n\t\t// scattering lengths\n\t\tpropOut.Add(strAtom + \".coh\", tl::var_to_str(ff.cCohb, g_iPrec));\n\t\tpropOut.Add(strAtom + \".incoh\", tl::var_to_str(ff.cIncb, g_iPrec));\n\n\t\t// cross-sections\n\t\tif(ff.bIncCohXs)\n\t\t\tpropOut.Add(strAtom + \".xsec_coh\", tl::var_to_str(ff.dCohXs, g_iPrec));\n\t\tif(ff.bIncIncXs)\n\t\t\tpropOut.Add(strAtom + \".xsec_incoh\", tl::var_to_str(ff.dIncXs, g_iPrec));\n\t\tif(ff.bIncScatXs)\n\t\t\tpropOut.Add(strAtom + \".xsec_scat\", tl::var_to_str(ff.dScatXs, g_iPrec));\n\t\tpropOut.Add(strAtom + \".xsec_absorp\", tl::var_to_str(ff.dAbsXs, g_iPrec));\n\n\t\t// abundances\n\t\tif(ff.bAb)\n\t\t\tpropOut.Add(strAtom + \".abund\", tl::var_to_str(ff.dAbOrHL, g_iPrec));\n\t\telse\n\t\t\tpropOut.Add(strAtom + \".hl\", tl::var_to_str(ff.dAbOrHL, g_iPrec));\n\n\t\t++iNucl;\n\t}\n\n\tpropOut.Add(\"scatlens.num_atoms\", tl::var_to_str(vecNuclei.size()));\n\n\tpropOut.Add(\"scatlens.source\", \"Scattering lengths and cross-sections extracted from NeutronPy (by D. Fobes)\"\n\t\t\" (which itself is based on this paper).\");\n\tpropOut.Add(\"scatlens.source_url\", \"https://github.com/neutronpy/neutronpy/blob/master/neutronpy/database/scattering_lengths.json\");\n\n\tif(!propOut.Save(\"res/data/scatlens.xml.gz\"))\n\t{\n\t\ttl::log_err(\"Cannot write \\\"res/data/scatlens.xml.gz\\\".\");\n\t\treturn false;\n\t}\n\n\treturn true;\n}\n\n\n\n// ============================================================================\n\n\nstruct mag_ffact\n{\n\tstd::string strName;\n\tstd::string strJ0_A, strJ0_a;\n\tstd::string strJ2_A, strJ2_a;\n\tstd::string strJ4_A, strJ4_a;\n};\n\nbool gen_magformfacts_npy()\n{\n\ttl::Prop propIn, propOut;\n\tpropIn.SetSeparator('/');\n\tpropOut.SetSeparator('.');\n\n\tif(!propIn.Load(\"tmp/magnetic_form_factors.json\", tl::PropType::JSON))\n\t{\n\t\ttl::log_err(\"Cannot load scattering length table \\\"tmp/magnetic_form_factors.json\\\".\");\n\t\treturn false;\n\t}\n\n\tstd::vector vecNuclei = propIn.GetChildNodes(\"/\");\n\tstd::vector vecFfacts;\n\n\tfor(const std::string& strNucl : vecNuclei)\n\t{\n\t\tauto vecJ0 = propIn.GetChildValues(\"/\" + strNucl + \"/j0\");\n\t\tauto vecJ2 = propIn.GetChildValues(\"/\" + strNucl + \"/j2\");\n\t\tauto vecJ4 = propIn.GetChildValues(\"/\" + strNucl + \"/j4\");\n\n\t\tmag_ffact ffact;\n\t\tffact.strName = strNucl;\n\t\tstd::string& strJ0A = ffact.strJ0_A;\n\t\tstd::string& strJ2A = ffact.strJ2_A;\n\t\tstd::string& strJ4A = ffact.strJ4_A;\n\t\tstd::string& strJ0a = ffact.strJ0_a;\n\t\tstd::string& strJ2a = ffact.strJ2_a;\n\t\tstd::string& strJ4a = ffact.strJ4_a;\n\n\t\tfor(std::size_t iJ=0; iJ bool\n\t\t{\n\t\t\tstd::string strName1 = tl::remove_chars(ff1.strName, std::string(\"+-0123456789\"));\n\t\t\tstd::string strName2 = tl::remove_chars(ff2.strName, std::string(\"+-0123456789\"));\n\n\t\t\tauto iter1 = g_mapElems.find(strName1);\n\t\t\tauto iter2 = g_mapElems.find(strName2);\n\n\t\t\tif(iter1 == g_mapElems.end())\n\t\t\t\ttl::log_err(\"Element \", strName1, \" not in table!\");\n\t\t\tif(iter2 == g_mapElems.end())\n\t\t\t\ttl::log_err(\"Element \", strName2, \" not in table!\");\n\n\t\t\treturn iter1->second < iter2->second;\n\t\t});\n\n\n\t// write database\n\tstd::size_t iNucl = 0;\n\tfor(const mag_ffact& ffact : vecFfacts)\n\t{\n\t\tstd::ostringstream ostr;\n\t\tostr << \"atom_\" << iNucl;\n\t\tstd::string strAtom = ostr.str();\n\n\t\tpropOut.Add(\"magffacts.j0.\" + strAtom + \".name\", ffact.strName);\n\t\tpropOut.Add(\"magffacts.j2.\" + strAtom + \".name\", ffact.strName);\n\t\tpropOut.Add(\"magffacts.j4.\" + strAtom + \".name\", ffact.strName);\n\n\t\tpropOut.Add(\"magffacts.j0.\" + strAtom + \".A\", ffact.strJ0_A);\n\t\tpropOut.Add(\"magffacts.j0.\" + strAtom + \".a\", ffact.strJ0_a);\n\n\t\tpropOut.Add(\"magffacts.j2.\" + strAtom + \".A\", ffact.strJ2_A);\n\t\tpropOut.Add(\"magffacts.j2.\" + strAtom + \".a\", ffact.strJ2_a);\n\n\t\tpropOut.Add(\"magffacts.j4.\" + strAtom + \".A\", ffact.strJ4_A);\n\t\tpropOut.Add(\"magffacts.j4.\" + strAtom + \".a\", ffact.strJ4_a);\n\n\t\t++iNucl;\n\t}\n\n\tpropOut.Add(\"magffacts.num_atoms\", tl::var_to_str(vecNuclei.size()));\n\n\tpropOut.Add(\"magffacts.source\", \"Magnetic form factor coefficients extracted from NeutronPy (by D. Fobes).\");\n\tpropOut.Add(\"magffacts.source_url\", \"https://github.com/neutronpy/neutronpy/blob/master/neutronpy/database/magnetic_form_factors.json\");\n\n\tif(!propOut.Save(\"res/data/magffacts.xml.gz\"))\n\t{\n\t\ttl::log_err(\"Cannot write \\\"res/data/magffacts.xml.gz\\\".\");\n\t\treturn false;\n\t}\n\n\treturn true;\n}\n\n\n// ============================================================================\n\n\nint main()\n{\n#ifdef NO_TERM_CMDS\n\ttl::Log::SetUseTermCmds(0);\n#endif\n\n\tstd::cout << \"Generating periodic table of elements ... \";\n\tbool bHasElems = gen_elements();\n\tif(bHasElems) std::cout << \"OK\" << std::endl;\n\n#ifndef NO_CLP\n\tstd::cout << \"Generating atomic form factor coefficient table ... \";\n\tif(gen_formfacts_clp()) std::cout << \"OK\" << std::endl;\n#endif\n\n\tstd::cout << \"Generating scattering length table ... \";\n\tif(gen_scatlens_npy())\n\t{\n\t\tstd::cout << \"OK\" << std::endl;\n\t}\n\telse\n\t{\n\t\tstd::cout << \"FAILED.\\nGenerating scattering length table (alternative) ... \";\n\t\tif(gen_scatlens()) std::cout << \"OK\" << std::endl;\n\t}\n\n\tstd::cout << \"Generating space group table ... \";\n\tif(gen_spacegroups())\n\t{\n\t\tstd::cout << \"OK\" << std::endl;\n\t}\n\telse\n\t{\n\t\tstd::cout << \"FAILED.\\n\";\n#ifndef NO_CLP\n\t\tstd::cout << \"Generating space group type table (alternative) ... \";\n\t\tif(gen_spacegroups_clp()) std::cout << \"OK\" << std::endl;\n#endif\n\t}\n\n\t//std::cout << \"Generating magnetic form factor coefficient table ... \";\n\t//if(gen_magformfacts()) std::cout << \"OK\" << std::endl;\n\n\tif(bHasElems)\n\t{\n\t\tstd::cout << \"Generating magnetic form factor coefficient table ... \";\n\t\tif(gen_magformfacts_npy()) std::cout << \"OK\" << std::endl;\n\t}\n\telse\n\t{\n\t\ttl::log_err(\"Cannot create magnetic form factor coefficient table, because required periodic table is invalid.\");\n\t}\n\n\treturn 0;\n}\n", "meta": {"hexsha": "88bd2f84c9617d97b3513f84f184841fa7fd9efa", "size": 19736, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "tools/gentab/gentab.cpp", "max_stars_repo_name": "t-weber/libcrystal", "max_stars_repo_head_hexsha": "2611288014047fe60010ee1b963a9e686b6ea77a", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "tools/gentab/gentab.cpp", "max_issues_repo_name": "t-weber/libcrystal", "max_issues_repo_head_hexsha": "2611288014047fe60010ee1b963a9e686b6ea77a", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tools/gentab/gentab.cpp", "max_forks_repo_name": "t-weber/libcrystal", "max_forks_repo_head_hexsha": "2611288014047fe60010ee1b963a9e686b6ea77a", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.6444121916, "max_line_length": 137, "alphanum_fraction": 0.6324483178, "num_tokens": 6363, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6150878555160665, "lm_q2_score": 0.5660185351961015, "lm_q1q2_score": 0.3481511269961152}} {"text": "#ifndef STAN_MATH_REV_MAT_FUN_MATRIX_EXP_MULTIPLY_HPP\n#define STAN_MATH_REV_MAT_FUN_MATRIX_EXP_MULTIPLY_HPP\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace stan {\nnamespace math {\n\n/**\n * Calculate adjoint of matrix exponential action\n * exp(At)*B when A is data and B is var, used for chaining action.\n *\n * @param Ad double array pointer to the data of matrix A\n * @param n dim of square matrix A\n * @param adjexpAB MatrixXd adjoint of exp(At)*B\n * @param t double time data\n * @return MatrixXd The adjoint of B.\n */\ninline Eigen::MatrixXd exp_action_chain_dv(double* Ad, const int& n,\n const Eigen::MatrixXd& adjexpAB,\n const double t) {\n using Eigen::Map;\n matrix_exp_action_handler handle;\n return handle.action(Map(Ad, n, n).transpose(), adjexpAB, t);\n}\n\n/**\n * Calculate adjoint of matrix exponential action\n * exp(At)*B when A is var and B is data, used for chaining action.\n *\n * @param Ad double array pointer to the data of matrix A\n * @param Bd double array pointer to the data of matrix B\n * @param n dim(nb. of rows) of square matrix A\n * @param m nb. of cols of matrix B\n * @param adjexpAB MatrixXd adjoint of exp(At)*B\n * @param t double time data\n * @return MatrixXd The adjoint of A.\n */\ninline Eigen::MatrixXd exp_action_chain_vd(double* Ad, double* Bd, const int& n,\n const int& m,\n const Eigen::MatrixXd& adjexpAB,\n const double t) {\n using Eigen::Map;\n using Eigen::Matrix;\n using Eigen::MatrixXd;\n Eigen::MatrixXd adjexpA = Eigen::MatrixXd::Zero(n, n);\n Eigen::MatrixXd adjA = Eigen::MatrixXd::Zero(n, n);\n\n // TODO(yizhang): a better way such as complex step approximation\n try {\n start_nested();\n\n adjexpA = adjexpAB * Map(Bd, n, m).transpose();\n Eigen::Matrix Av(n, n);\n for (int i = 0; i < Av.size(); ++i) {\n Av(i) = to_var(Ad[i]);\n }\n std::vector Avec(Av.data(), Av.data() + Av.size());\n Eigen::Matrix expA\n = matrix_exp(Av);\n std::vector g;\n for (size_type i = 0; i < expA.size(); ++i) {\n stan::math::set_zero_all_adjoints_nested();\n expA.coeffRef(i).grad(Avec, g);\n for (size_type j = 0; j < adjA.size(); ++j) {\n adjA(j) += adjexpA(i) * g[j];\n }\n }\n } catch (const std::exception& e) {\n recover_memory_nested();\n throw;\n }\n recover_memory_nested();\n return adjA;\n}\n\n/**\n * This is a subclass of the vari class for matrix\n * exponential action exp(At) * B where A is a double\n * NxN matrix and B is a NxCb matrix.\n *\n * The class stores the structure of each matrix,\n * the double values of A and B, and pointers to\n * the varis for A and B if A or B is a var. It\n * also instantiates and stores pointers to\n * varis for all elements of A * B.\n *\n * @tparam Ta Scalar type of matrix A\n * @tparam N rows and cols of A\n * @tparam Tb Scalar type for matrix B\n * @tparam Cb cols for matrix B\n */\ntemplate \nclass matrix_exp_action_vari : public vari {\n public:\n int n_;\n int B_cols_;\n int A_size_;\n int B_size_;\n double t_;\n double* Ad_;\n double* Bd_;\n vari** variRefA_;\n vari** variRefB_;\n vari** variRefexpAB_;\n\n /**\n * Constructor: vari child-class of matrix_exp_action_vari.\n * @param A statically-sized matirx\n * @param B statically-sized matirx\n * @param t double scalar time.\n */\n matrix_exp_action_vari(const Eigen::Matrix& A,\n const Eigen::Matrix& B, const double& t)\n : vari(0.0),\n n_(A.rows()),\n B_cols_(B.cols()),\n A_size_(A.size()),\n B_size_(B.size()),\n t_(t),\n Ad_(ChainableStack::instance().memalloc_.alloc_array(A_size_)),\n Bd_(ChainableStack::instance().memalloc_.alloc_array(B_size_)),\n variRefA_(\n ChainableStack::instance().memalloc_.alloc_array(A_size_)),\n variRefB_(\n ChainableStack::instance().memalloc_.alloc_array(B_size_)),\n variRefexpAB_(\n ChainableStack::instance().memalloc_.alloc_array(B_size_)) {\n using Eigen::Map;\n using Eigen::MatrixXd;\n for (size_type i = 0; i < A.size(); ++i) {\n variRefA_[i] = A.coeffRef(i).vi_;\n Ad_[i] = A.coeffRef(i).val();\n }\n for (size_type i = 0; i < B.size(); ++i) {\n variRefB_[i] = B.coeffRef(i).vi_;\n Bd_[i] = B.coeffRef(i).val();\n }\n matrix_exp_action_handler handle;\n MatrixXd expAB = handle.action(Map(Ad_, n_, n_),\n Map(Bd_, n_, B_cols_), t_);\n for (size_type i = 0; i < expAB.size(); ++i)\n variRefexpAB_[i] = new vari(expAB.coeffRef(i), false);\n }\n\n /**\n * Chain command for the adjoint of matrix exp action.\n */\n virtual void chain() {\n using Eigen::Map;\n using Eigen::MatrixXd;\n MatrixXd adjexpAB(n_, B_cols_);\n\n for (size_type i = 0; i < adjexpAB.size(); ++i)\n adjexpAB(i) = variRefexpAB_[i]->adj_;\n\n MatrixXd adjA = exp_action_chain_vd(Ad_, Bd_, n_, B_cols_, adjexpAB, t_);\n MatrixXd adjB = exp_action_chain_dv(Ad_, n_, adjexpAB, t_);\n\n for (size_type i = 0; i < A_size_; ++i) {\n variRefA_[i]->adj_ += adjA(i);\n }\n for (size_type i = 0; i < B_size_; ++i) {\n variRefB_[i]->adj_ += adjB(i);\n }\n }\n};\n\n/**\n * This is a subclass of the vari class for matrix\n * exponential action exp(At) * B where A is an N by N\n * matrix of double, B is N by Cb, and t is data(time)\n *\n * The class stores the structure of each matrix,\n * the double values of A and B, and pointers to\n * the varis for A and B if B is a var. It\n * also instantiates and stores pointers to\n * varis for all elements of exp(At) * B.\n *\n * @tparam N Rows and cols for matrix A, also rows for B\n * @tparam Tb Scalar type for matrix B\n * @tparam Cb Columns for matrix B\n */\ntemplate \nclass matrix_exp_action_vari : public vari {\n public:\n int n_;\n int B_cols_;\n int A_size_;\n int B_size_;\n double t_;\n double* Ad_;\n double* Bd_;\n vari** variRefB_;\n vari** variRefexpAB_;\n\n /**\n * Constructor for matrix_exp_action_vari.\n *\n * All memory allocated in\n * ChainableStack's stack_alloc arena.\n *\n * It is critical for the efficiency of this object\n * that the constructor create new varis that aren't\n * popped onto the var_stack_, but rather are\n * popped onto the var_nochain_stack_. This is\n * controlled to the second argument to\n * vari's constructor.\n *\n * @param A matrix\n * @param B matrix\n * @param t double\n */\n matrix_exp_action_vari(const Eigen::Matrix& A,\n const Eigen::Matrix& B, const double& t)\n : vari(0.0),\n n_(A.rows()),\n B_cols_(B.cols()),\n A_size_(A.size()),\n B_size_(B.size()),\n t_(t),\n Ad_(ChainableStack::instance().memalloc_.alloc_array(A_size_)),\n Bd_(ChainableStack::instance().memalloc_.alloc_array(B_size_)),\n variRefB_(\n ChainableStack::instance().memalloc_.alloc_array(B_size_)),\n variRefexpAB_(\n ChainableStack::instance().memalloc_.alloc_array(B_size_)) {\n using Eigen::Map;\n using Eigen::MatrixXd;\n for (size_type i = 0; i < A.size(); ++i)\n Ad_[i] = A.coeffRef(i);\n for (size_type i = 0; i < B.size(); ++i) {\n variRefB_[i] = B.coeffRef(i).vi_;\n Bd_[i] = B.coeffRef(i).val();\n }\n matrix_exp_action_handler handle;\n MatrixXd expAB = handle.action(Map(Ad_, n_, n_),\n Map(Bd_, n_, B_cols_), t_);\n for (size_type i = 0; i < expAB.size(); ++i)\n variRefexpAB_[i] = new vari(expAB.coeffRef(i), false);\n }\n\n /**\n * Chain for matrix_exp_action_vari.\n */\n virtual void chain() {\n using Eigen::Map;\n using Eigen::MatrixXd;\n MatrixXd adjexpAB(n_, B_cols_);\n // MatrixXd adjB(n_, B_cols_);\n\n for (size_type i = 0; i < adjexpAB.size(); ++i)\n adjexpAB(i) = variRefexpAB_[i]->adj_;\n\n MatrixXd adjB = exp_action_chain_dv(Ad_, n_, adjexpAB, t_);\n\n for (size_type i = 0; i < B_size_; ++i) {\n variRefB_[i]->adj_ += adjB(i);\n }\n }\n};\n\n/**\n * This is a subclass of the vari class for matrix\n * exponential action exp(At) * B where A is an N by N\n * matrix of var, B is N by Cb matrix of double, and t is data(time)\n *\n * The class stores the structure of each matrix,\n * the double values of A and B, and pointers to\n * the varis for A and B if B is a var. It\n * also instantiates and stores pointers to\n * varis for all elements of exp(At) * B.\n *\n * @tparam Ta Scalar type for matrix A\n * @tparam N Rows and cols for matrix A, also rows for B\n * @tparam Cb Columns for matrix B\n */\ntemplate \nclass matrix_exp_action_vari : public vari {\n public:\n int n_;\n int B_cols_;\n int A_size_;\n int B_size_;\n double t_;\n double* Ad_;\n double* Bd_;\n vari** variRefA_;\n vari** variRefexpAB_;\n\n /**\n * Constructor for matrix_exp_action_vari.\n *\n * All memory allocated in\n * ChainableStack's stack_alloc arena.\n *\n * It is critical for the efficiency of this object\n * that the constructor create new varis that aren't\n * popped onto the var_stack_, but rather are\n * popped onto the var_nochain_stack_. This is\n * controlled to the second argument to\n * vari's constructor.\n *\n * @param A matrix\n * @param B matrix\n * @param t double\n */\n matrix_exp_action_vari(const Eigen::Matrix& A,\n const Eigen::Matrix& B, const double& t)\n : vari(0.0),\n n_(A.rows()),\n B_cols_(B.cols()),\n A_size_(A.size()),\n B_size_(B.size()),\n t_(t),\n Ad_(ChainableStack::instance().memalloc_.alloc_array(A_size_)),\n Bd_(ChainableStack::instance().memalloc_.alloc_array(B_size_)),\n variRefA_(\n ChainableStack::instance().memalloc_.alloc_array(A_size_)),\n variRefexpAB_(\n ChainableStack::instance().memalloc_.alloc_array(B_size_)) {\n using Eigen::Map;\n using Eigen::MatrixXd;\n for (size_type i = 0; i < A.size(); ++i) {\n variRefA_[i] = A.coeffRef(i).vi_;\n Ad_[i] = A.coeffRef(i).val();\n }\n for (size_type i = 0; i < B.size(); ++i) {\n Bd_[i] = B.coeffRef(i);\n }\n matrix_exp_action_handler handle;\n MatrixXd expAB = handle.action(Map(Ad_, n_, n_),\n Map(Bd_, n_, B_cols_), t_);\n for (size_type i = 0; i < expAB.size(); ++i)\n variRefexpAB_[i] = new vari(expAB.coeffRef(i), false);\n }\n\n virtual void chain() {\n using Eigen::Map;\n using Eigen::MatrixXd;\n MatrixXd adjexpAB(n_, B_cols_);\n\n for (size_type i = 0; i < adjexpAB.size(); ++i)\n adjexpAB(i) = variRefexpAB_[i]->adj_;\n\n MatrixXd adjA = exp_action_chain_vd(Ad_, Bd_, n_, B_cols_, adjexpAB, t_);\n\n for (size_type i = 0; i < A_size_; ++i) {\n variRefA_[i]->adj_ += adjA(i);\n }\n }\n};\n\n/**\n * Return product of exp(At) and B, where A is a NxN matrix,\n * B is a NxCb matrix, and t is a double\n * @tparam Ta scalar type matrix A\n * @tparam N Rows and cols matrix A, also rows of matrix B\n * @tparam Tb scalar type matrix B\n * @tparam Cb Columns matrix B\n * @param[in] A Matrix\n * @param[in] B Matrix\n * @param[in] t double\n * @return exponential of At multiplies B\n */\ntemplate \ninline typename boost::enable_if_c::value\n || boost::is_same::value,\n Eigen::Matrix >::type\nmatrix_exp_action(const Eigen::Matrix& A,\n const Eigen::Matrix& B, const double& t = 1.0) {\n matrix_exp_action_vari* baseVari\n = new matrix_exp_action_vari(A, B, t);\n Eigen::Matrix expAB_v(A.rows(), B.cols());\n for (size_type i = 0; i < expAB_v.size(); ++i) {\n expAB_v.coeffRef(i).vi_ = baseVari->variRefexpAB_[i];\n }\n return expAB_v;\n}\n\n/**\n * Wrapper of matrix_exp_action function for a more literal name\n * @tparam Ta scalar type matrix A\n * @tparam Tb scalar type matrix B\n * @tparam Cb Columns matrix B\n * @param[in] A Matrix\n * @param[in] B Matrix\n * @return exponential of A multiplies B\n */\ntemplate \ninline Eigen::Matrix::type, -1, Cb>\nmatrix_exp_multiply(const Eigen::Matrix& A,\n const Eigen::Matrix& B) {\n check_nonzero_size(\"matrix_exp_multiply\", \"input matrix\", A);\n check_nonzero_size(\"matrix_exp_multiply\", \"input matrix\", B);\n check_multiplicable(\"matrix_exp_multiply\", \"A\", A, \"B\", B);\n check_square(\"matrix_exp_multiply\", \"input matrix\", A);\n return matrix_exp_action(A, B);\n}\n\n} // namespace math\n} // namespace stan\n\n#endif\n", "meta": {"hexsha": "afde7b2c8600b9c5b04a3efd1a05d5074ca79a29", "size": 13682, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "stan/math/rev/mat/fun/matrix_exp_multiply.hpp", "max_stars_repo_name": "cqfd/math", "max_stars_repo_head_hexsha": "68b8f7e2effb1a23abe8524ff429a212653b53a3", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "stan/math/rev/mat/fun/matrix_exp_multiply.hpp", "max_issues_repo_name": "cqfd/math", "max_issues_repo_head_hexsha": "68b8f7e2effb1a23abe8524ff429a212653b53a3", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "stan/math/rev/mat/fun/matrix_exp_multiply.hpp", "max_forks_repo_name": "cqfd/math", "max_forks_repo_head_hexsha": "68b8f7e2effb1a23abe8524ff429a212653b53a3", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.8894230769, "max_line_length": 80, "alphanum_fraction": 0.6257126151, "num_tokens": 3924, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7185943925708562, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.3480728124344397}} {"text": "/**\n * @file\n * @copyright This code is licensed under the 3-clause BSD license.\\n\n * Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group.\\n\n * See LICENSE.txt for details.\n */\n\n#include \"DihedralTerm.h\"\n#include \"../MMExceptions.h\"\n#include \n#include \n#include \n\nnamespace Scine {\nnamespace MolecularMechanics {\n\nDihedralTerm::DihedralTerm(AtomIndex firstAtom, AtomIndex secondAtom, AtomIndex thirdAtom, AtomIndex fourthAtom,\n const Dihedral& dihedral, const DihedralType& typeOfDihedral)\n : firstAtom_(firstAtom),\n secondAtom_(secondAtom),\n thirdAtom_(thirdAtom),\n fourthAtom_(fourthAtom),\n dihedral_(dihedral),\n typeOfDihedral_(typeOfDihedral) {\n}\n\nDihedralTerm::~DihedralTerm() = default;\n\ndouble DihedralTerm::evaluateDihedralTerm(const Utils::PositionCollection& positions,\n Utils::AtomicSecondDerivativeCollection& derivatives) const {\n if (this->disabled_)\n return 0.0;\n if (!dihedral_.hasParameters()) // Check this only if this term is not disabled\n throw MMDihedralParametersNotAvailableException(typeOfDihedral_.a1, typeOfDihedral_.a2, typeOfDihedral_.a3,\n typeOfDihedral_.a4);\n\n // Calculating the dihedral energy and its derivatives according to\n // A. Blondel, M. Karplus, New Formulation for Derivatives of Torsion Angles and Improper Torsion Angles in Molecular\n // Mechanics: Elimination of Singularities, JCC, 17, 1996, 1132-1141.\n Eigen::Vector3d F(positions.row(firstAtom_) - positions.row(secondAtom_));\n Eigen::Vector3d G(positions.row(secondAtom_) - positions.row(thirdAtom_));\n Eigen::Vector3d H(positions.row(fourthAtom_) - positions.row(thirdAtom_));\n\n auto A = F.cross(G);\n auto B = H.cross(G);\n\n double A2 = A.squaredNorm();\n double B2 = B.squaredNorm();\n // double A4 = A2 * A2;\n // double B4 = B2 * B2;\n double G1 = G.norm();\n // double G2 = G1 * G1;\n // double G3 = G1 * G2;\n\n // Values needed for first derivatives\n auto gba2a = G1 / A2 * A;\n auto fgba2ga = F.dot(G) / (A2 * G1) * A;\n auto hgbb2gb = H.dot(G) / (B2 * G1) * B;\n auto gbb2b = G1 / B2 * B;\n\n // First derivatives:\n Eigen::Vector3d firstDer1 = -gba2a;\n Eigen::Vector3d firstDer2 = gba2a + fgba2ga - hgbb2gb;\n Eigen::Vector3d firstDer3 = hgbb2gb - fgba2ga - gbb2b;\n Eigen::Vector3d firstDer4 = gbb2b;\n\n // // Values needed for second derivatives // TODO\n // auto gca = G.cross(A);\n // auto gcb = G.cross(B);\n // auto fca = F.cross(A);\n // auto hcb = H.cross(B);\n // auto d2df2 = (Utils::tensor(A, gca) + Utils::tensor(gca, A)) * (G.norm() / A4);\n // auto d2dh2 = (Utils::tensor(B, gcb) + Utils::tensor(gcb, B)) * (-G.norm() / B4);\n // auto d2dg2 = (Utils::tensor(gca, A) + Utils::tensor(A, gca)) * (1.0 / (2 * G3 * A2)) +\n // (Utils::tensor(A, fca) + Utils::tensor(fca, A)) * (F.dot(G) / (G.norm() * A4)) +\n // (Utils::tensor(gcb, B) + Utils::tensor(B, gcb)) * (-1.0 / (2 * G3 * B2)) +\n // (Utils::tensor(B, hcb) + Utils::tensor(hcb, B)) * (-H.dot(G) / (G.norm() * B4));\n // auto d2dfdg = (Utils::tensor(-fca, A) * G.squaredNorm() + Utils::tensor(A, -gca) * F.dot(G)) * (1.0 / (G.norm() *\n // A4)); auto d2dhdg = (Utils::tensor(-hcb, B) * G.squaredNorm() + Utils::tensor(B, -gcb) * H.dot(G)) * (-1.0 /\n // (G.norm() * B4));\n\n // Derivative objects for theta\n Utils::AutomaticDifferentiation::Second3D h1, h2, h3, h4;\n\n // // Add contributions to second derivatives // TODO\n // setSecondDerivative(h1, d2df2, 1.0, 1.0);\n // setSecondDerivative(h2, d2df2, -1.0, -1.0);\n // setSecondDerivative(h2, d2dg2, 1.0, 1.0);\n // setSecondDerivative(h2, d2dfdg, -1.0, 1.0);\n // setSecondDerivative(h3, d2dh2, -1.0, -1.0);\n // setSecondDerivative(h3, d2dg2, -1.0, -1.0);\n // setSecondDerivative(h3, d2dhdg, -1.0, -1.0);\n // setSecondDerivative(h4, d2dh2, 1.0, 1.0);\n\n // Add first derivatives contributions\n h1.setFirst3D(firstDer1);\n h2.setFirst3D(firstDer2);\n h3.setFirst3D(firstDer3);\n h4.setFirst3D(firstDer4);\n\n double theta = getTheta(A, B, G);\n auto result = dihedral_.getInteraction(theta);\n\n // Apply chain rule to get derivatives with respect to the energy\n derivatives[firstAtom_] += threeDimDer(result, h1);\n derivatives[secondAtom_] += threeDimDer(result, h2);\n derivatives[thirdAtom_] += threeDimDer(result, h3);\n derivatives[fourthAtom_] += threeDimDer(result, h4);\n\n return result.value();\n}\n\nUtils::AutomaticDifferentiation::Second3D DihedralTerm::threeDimDer(const Utils::AutomaticDifferentiation::Second1D& energy,\n const Utils::AutomaticDifferentiation::Second3D& alpha) const {\n return {energy.value(),\n energy.first() * alpha.dx(),\n energy.first() * alpha.dy(),\n energy.first() * alpha.dz(),\n energy.second() * alpha.dx() * alpha.dx() + energy.first() * alpha.XX(),\n energy.second() * alpha.dy() * alpha.dy() + energy.first() * alpha.YY(),\n energy.second() * alpha.dz() * alpha.dz() + energy.first() * alpha.ZZ(),\n energy.second() * alpha.dx() * alpha.dy() + energy.first() * alpha.XY(),\n energy.second() * alpha.dx() * alpha.dz() + energy.first() * alpha.XZ(),\n energy.second() * alpha.dy() * alpha.dz() + energy.first() * alpha.YZ()};\n}\n\nvoid DihedralTerm::setSecondDerivative(Utils::AutomaticDifferentiation::Second3D& h, const Utils::Tensor33& tensor,\n double derFirst, double derSecond) const {\n double f = derFirst * derSecond;\n h.setXX(h.XX() + f * tensor.x().x());\n h.setYY(h.YY() + f * tensor.y().y());\n h.setZZ(h.ZZ() + f * tensor.z().z());\n h.setXY(h.XY() + f * tensor.x().y() + f * tensor.y().x()); // TODO: DO I need 1/2 ?\n h.setXZ(h.XZ() + f * tensor.x().z() + f * tensor.z().x());\n h.setYZ(h.YZ() + f * tensor.y().z() + f * tensor.z().y());\n}\n\ndouble DihedralTerm::getTheta(const Eigen::Vector3d& A, const Eigen::Vector3d& B, const Eigen::Vector3d& G) {\n double acosArg = A.dot(B) / (A.norm() * B.norm());\n // acosArg *= -1;\n double theta = acos(acosArg);\n // Needed because of numerical instabilities provoking theta = nan\n if (acosArg >= 1)\n theta = 0;\n else if (acosArg <= -1)\n theta = 4.0 * atan(1);\n\n // Invert sign of theta if it should be negative (NB: acos delivers only values between 0 and pi)\n double asinArg = B.cross(A).dot(G) / (A.norm() * B.norm() * G.norm());\n if (asinArg < 0) {\n theta *= -1;\n }\n\n return theta;\n}\n\nDihedralType DihedralTerm::getTypeOfDihedral() const {\n return typeOfDihedral_;\n}\n\nint DihedralTerm::getFirstAtom() const {\n return firstAtom_;\n}\n\nint DihedralTerm::getSecondAtom() const {\n return secondAtom_;\n}\n\nint DihedralTerm::getThirdAtom() const {\n return thirdAtom_;\n}\n\nint DihedralTerm::getFourthAtom() const {\n return fourthAtom_;\n}\n\n} // namespace MolecularMechanics\n} // namespace Scine", "meta": {"hexsha": "a3b4a799bc97fd06b7f900ae191f17596218bb33", "size": 7059, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/Swoose/Swoose/MolecularMechanics/Interactions/DihedralTerm.cpp", "max_stars_repo_name": "qcscine/swoose", "max_stars_repo_head_hexsha": "55a74259153845ade607784f26455fd96dddce07", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-12-15T09:31:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-15T09:35:36.000Z", "max_issues_repo_path": "src/Swoose/Swoose/MolecularMechanics/Interactions/DihedralTerm.cpp", "max_issues_repo_name": "qcscine/swoose", "max_issues_repo_head_hexsha": "55a74259153845ade607784f26455fd96dddce07", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Swoose/Swoose/MolecularMechanics/Interactions/DihedralTerm.cpp", "max_forks_repo_name": "qcscine/swoose", "max_forks_repo_head_hexsha": "55a74259153845ade607784f26455fd96dddce07", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.6573033708, "max_line_length": 131, "alphanum_fraction": 0.6261510129, "num_tokens": 2224, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7185943925708561, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.34807281243443966}} {"text": "#include \n\n#if defined(USE_OPENGL)\n #include \n#endif\n\n#include \n\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\nenum class SHADEMODE {\n NONE,\n FLAT,\n GOURAUD,\n PHONG,\n};\n\nconstexpr int NX = 512;\nconstexpr int NY = 512;\n\nColor* buffer;\nfloat zbuf[NX][NY];\n\nPPM ppm;\n\nchar shade_str[20];\nSHADEMODE shade_mode;\nvoid assign_shade_mode() {\n if (strcmp(shade_str, \"NONE\") == 0)\n shade_mode = SHADEMODE::NONE;\n else if (strcmp(shade_str, \"FLAT\") == 0)\n shade_mode = SHADEMODE::FLAT;\n else if (strcmp(shade_str, \"GOURAUD\") == 0)\n shade_mode = SHADEMODE::GOURAUD;\n else\n shade_mode = SHADEMODE::PHONG;\n}\n\nvoid cleanup() {\n delete[] buffer;\n}\n\n#if defined(USE_OPENGL)\nvoid gl_display() {\n glClearColor(0,0,0,1);\n glClear(GL_COLOR_BUFFER_BIT);\n\n float* float_buffer = new float[3*NX*NY];\n\n int k = 0;\n for (int i = 0; i < NX; i++) {\n for (int j = 0; j < NY; j++) {\n float_buffer[k++] = buffer[j*NY + i].r;\n float_buffer[k++] = buffer[j*NY + i].g;\n float_buffer[k++] = buffer[j*NY + i].b;\n }\n }\n\n glDrawPixels(NX, NY, GL_RGB, GL_FLOAT, float_buffer);\n\n glutSwapBuffers();\n\n delete[] float_buffer;\n}\n\nvoid gl_keyboard(unsigned char key, int x, int y) {\n switch (key) {\n // ESC\n case 27:\n cleanup();\n exit(EXIT_SUCCESS);\n }\n}\n#endif\n\nint clamp(int x, int min, int max) {\n return std::max(min, std::min(x, max));\n}\n\nvoid draw(int x, int y, const Color& color) {\n#if defined(USE_OPENGL)\n buffer[x*NY + y] = color.correct(2.2f);\n#else\n auto c = color.correct(2.2f);\n\n auto r = clamp(c.r * 255, 0, 255);\n auto g = clamp(c.g * 255, 0, 255);\n auto b = clamp(c.b * 255, 0, 255);\n easyppm_set(&ppm, x, y, easyppm_rgb(r,g,b));\n#endif\n}\n\ntemplate \nT lerp(T a, T b, T c, float alpha, float beta) {\n return (a-c)*alpha + (b-c)*beta + c;\n}\n\nvoid rasterize(const Triangle& tri, const Light& light, const Material& mat, const Eigen::Matrix4f& M) {\n // Backface culling\n auto v = tri.centroid().normalized();\n if (v.dot(tri.n) > 0)\n return;\n\n // Convert triangle coordinates from world to viewport\n auto a_vp = vec4to3(M * Eigen::Vector4f(tri.a[0], tri.a[1], tri.a[2], 1.0f));\n auto b_vp = vec4to3(M * Eigen::Vector4f(tri.b[0], tri.b[1], tri.b[2], 1.0f));\n auto c_vp = vec4to3(M * Eigen::Vector4f(tri.c[0], tri.c[1], tri.c[2], 1.0f));\n\n // Viewport triangle bounds\n auto bounds = Triangle(a_vp, b_vp, c_vp).bounds();\n\n // Viewport triangle vertex values\n float ax = a_vp[0], ay = a_vp[1], az = a_vp[2];\n float bx = b_vp[0], by = b_vp[1], bz = b_vp[2];\n float cx = c_vp[0], cy = c_vp[1], cz = c_vp[2];\n\n Eigen::Matrix2f A;\n A << (ax-cx), (bx-cx),\n (ay-cy), (by-cy);\n\n // Step through viewport bounding box and check whether pixel is in triangle\n for (int y = bounds.ymin; y <= bounds.ymax; y++) {\n for (int x = bounds.xmin; x <= bounds.xmax; x++) {\n // Solve Ax=b for barycentric coordinates\n Eigen::Vector2f bary = A.lu().solve(Eigen::Vector2f(x-cx, y-cy));\n\n float alpha = bary[0];\n float beta = bary[1];\n\n float z = lerp(az, bz, cz, alpha, beta);\n\n if (alpha >= 0 && beta >= 0 && alpha + beta <= 1 && z > zbuf[x][y]) {\n zbuf[x][y] = z;\n if (shade_mode == SHADEMODE::NONE) {\n // White\n draw(x, y, Color::white());\n } else if (shade_mode == SHADEMODE::FLAT) {\n // Centroid color\n draw(x, y, tri.shade(tri.centroid(), tri.n, light, mat));\n } else if (shade_mode == SHADEMODE::GOURAUD) {\n // Vertex colors\n auto ac = tri.shade(tri.a, tri.an, light, mat);\n auto bc = tri.shade(tri.b, tri.bn, light, mat);\n auto cc = tri.shade(tri.c, tri.cn, light, mat);\n\n draw(x, y, lerp(ac, bc, cc, alpha, beta));\n } else {\n // Interpolate position and normal\n auto p = lerp(tri.a, tri.b, tri.c, alpha, beta);\n auto n = lerp(tri.an, tri.bn, tri.cn, alpha, beta);\n\n draw(x, y, tri.shade(p, n, light, mat));\n }\n }\n }\n }\n}\n\nint main(int argc, char* argv[]) {\n // Parse system arguments\n argparser ap = argparser_create(argc, argv, PARSEMODE_LENIENT);\n argparser_add(&ap, \"-s\", \"--shading\", ARGTYPE_STRING, &shade_str, \"Shade mode\");\n argparser_parse(&ap);\n\n assign_shade_mode();\n\n#ifndef USE_OPENGL\n ppm = easyppm_create(NX, NY, IMAGETYPE_PPM);\n#endif\n\n constexpr float l = -0.1f;\n constexpr float r = 0.1f;\n constexpr float b = -0.1f;\n constexpr float t = 0.1f;\n constexpr float n = -0.1f;\n constexpr float f = -1000.0f;\n\n Eigen::Matrix4f M, M_world, M_m, M_cam, P, M_orth, M_vp;\n\n // Modeling transform\n M_m << 2.0f, 0.0f, 0.0f, 0.0f,\n 0.0f, 2.0f, 0.0f, 0.0f,\n 0.0f, 0.0f, 2.0f, -7.0f,\n 0.0f, 0.0f, 0.0f, 1.0f;\n\n // Camera transform\n M_cam << 1.0f, 0.0f, 0.0f, 0.0f,\n 0.0f, 1.0f, 0.0f, 0.0f,\n 0.0f, 0.0f, 1.0f, 0.0f,\n 0.0f, 0.0f, 0.0f, 1.0f;\n\n // Perspective transform\n P << n, 0.0f, 0.0f, 0.0f,\n 0.0f, n, 0.0f, 0.0f,\n 0.0f, 0.0f, n+f, -f*n,\n 0.0f, 0.0f, 1.0f, 0.0f;\n\n // Orthographic transform\n M_orth << 2.0f/(r-l), 0.0f, 0.0f, -(r+l)/(r-l),\n 0.0f, 2.0f/(t-b), 0.0f, -(t+b)/(t-b),\n 0.0f, 0.0f, 2.0f/(n-f), -(n+f)/(n-f),\n 0.0f, 0.0f, 0.0f, 1.0f;\n\n // Viewport transform\n M_vp << NX/2.0f, 0.0f, 0.0f, (NX-1)/2.0f,\n 0.0f, NY/2.0f, 0.0f, (NY-1)/2.0f,\n 0.0f, 0.0f, 1.0f, 0.0f,\n 0.0f, 0.0f, 0.0f, 1.0f;\n\n // World transform\n M_world = M_cam * M_m;\n\n // \"Viewport\" transform\n M = M_vp * M_orth * P;\n\n // Sphere\n Color ka(0.0f, 1.0f, 0.0f);\n Color kd(0.0f, 0.5f, 0.0f);\n Color ks(0.5f, 0.5f, 0.5f);\n Material mat(ka, kd, ks, 32);\n Sphere sphere(mat, M_world);\n\n // Light\n Light light(Eigen::Vector3f(-4, 4, -3), 1);\n\n // Black buffer\n buffer = new Color[NX*NY];\n for (int x = 0; x < NX; x++)\n for (int y = 0; y < NY; y++)\n draw(x, y, Color::black());\n\n // Z buffer starts at max depth\n for (int x = 0; x < NX; x++)\n for (int y = 0; y < NY; y++)\n zbuf[x][y] = f;\n\n // Rasterize sphere\n for (const auto& tri : sphere.triangles)\n rasterize(tri, light, mat, M);\n\n#if defined(USE_OPENGL)\n // Write buffer to OpenGL window\n char window_name[50];\n if (shade_mode == SHADEMODE::NONE) strcpy(window_name, \"Part 1 (Unshaded)\");\n else if (shade_mode == SHADEMODE::FLAT) strcpy(window_name, \"Part 2 (Flat Shading)\");\n else if (shade_mode == SHADEMODE::GOURAUD) strcpy(window_name, \"Part 3 (Gouraud Shading)\");\n else strcpy(window_name, \"Part 4 (Phong Shading)\");\n glutInit(&argc, argv);\n glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);\n glutInitWindowSize(NX, NY);\n glutCreateWindow(window_name);\n glutDisplayFunc(gl_display);\n glutKeyboardFunc(gl_keyboard);\n glutMainLoop();\n#else\n // Write buffer to image file\n char ppmpath[50];\n if (shade_mode == SHADEMODE::NONE) strcpy(ppmpath, \"images/part1-unshaded.ppm\");\n else if (shade_mode == SHADEMODE::FLAT) strcpy(ppmpath, \"images/part2-flat.ppm\");\n else if (shade_mode == SHADEMODE::GOURAUD) strcpy(ppmpath, \"images/part3-gouraud.ppm\");\n else strcpy(ppmpath, \"images/part4-phong.ppm\");\n\n easyppm_invert_y(&ppm);\n easyppm_write(&ppm, ppmpath);\n easyppm_destroy(&ppm);\n#endif\n\n cleanup();\n\n return EXIT_SUCCESS;\n}\n", "meta": {"hexsha": "a33258b8d15d25801f4002af54873b1097c99518", "size": 8734, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "main.cpp", "max_stars_repo_name": "zanzo420/rasterizer", "max_stars_repo_head_hexsha": "afc974e6289c84982e0f42070aa0b8d96bcb6cf9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-06-12T20:31:46.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-12T20:31:46.000Z", "max_issues_repo_path": "main.cpp", "max_issues_repo_name": "zanzo420/rasterizer", "max_issues_repo_head_hexsha": "afc974e6289c84982e0f42070aa0b8d96bcb6cf9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "main.cpp", "max_forks_repo_name": "zanzo420/rasterizer", "max_forks_repo_head_hexsha": "afc974e6289c84982e0f42070aa0b8d96bcb6cf9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-09-22T06:03:16.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-04T13:10:48.000Z", "avg_line_length": 31.0818505338, "max_line_length": 104, "alphanum_fraction": 0.4993130295, "num_tokens": 2817, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7185943925708561, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.34807281243443966}} {"text": "#include \n#include \n#include \n#include \n#include \n\n#include \"../include/KF.h\"\n#include \"../include/dsho.h\"\n#include \"../include/matern32.h\"\n#include \"../include/ndsho.h\"\n\n\nusing namespace Eigen;\nusing namespace std;\n\n#define TWOPI 6.283185307179586\n\n// function to read a space separated file\n\nstd::vector load_csv (const std::string & path) {\n std::ifstream indata;\n indata.open(path);\n std::string line;\n std::vector values;\n uint rows = 0;\n while (std::getline(indata, line)) {\n std::stringstream lineStream(line);\n std::string cell;\n while (std::getline(lineStream, cell, ' ')) {\n //cout << std::stod(cell) << endl;\n values.push_back(std::stod(cell));\n }\n ++rows;\n }\n return values;\n}\n\nint main() {\n\n\t// read file with two component damped simple harmonic oscillator simulated data\n\t//std::vector values = load_csv(\"two_comp_dsho.txt\");\n\t//cout << values.size() << endl;\n\n\t// map data to VectorXds\n\t//VectorXd times = Map > (values.data(), 10000);\n\t//VectorXd yi = Map > (values.data()+1, 10000);\n\n\n int vecsize = 10000;\n\t// map data to VectorXds\n\tVectorXd yi(vecsize);\n VectorXd times = Eigen::VectorXd::Random(vecsize);\n times.array() += 1.0;\n times.array() *= (100*0.5);\n std::sort(times.data(), times.data() + times.size());\n\n\n\t// this is the observational error vector\n\tVectorXd yerr = VectorXd::Ones(yi.size());\n\tyerr.array() *= 0.05;\n\n\tVectorXd y_sim, y_sim_one;\n\n\tfor(int j=0; j < 24; j++) {\n\t\t//auto const seed = std::random_device()();\n\t\tint seed = 123;\n\t\tstd::mt19937 rng(seed);\n\t\tcout << seed << endl;\n\t\t// set parameters for a 2 component DSHO model\n\t\tEigen::Vector2d omegas,Qpars,varfs;\n\t\tEigen::Matrix omega_one, Qpar_one, varf_one;\n\t\tdouble omega0 = 8; // this component stays fixed\n\t\tdouble period_list[6] = {1.0, 2.0, 4.0, 8.0, 16.0, 32.0};\n\t\tstd::cout << j/6 << j%6 << std::endl;\n\t\tdouble omega1 = TWOPI / period_list[j%6];\n\t\tdouble Q0 = 10.0;\n\t\tdouble Q1 = 10.0;\n\t\tdouble varf0 = 1.0;\n\t\tdouble varf1 = 1.0;\n\t\tif ((j/6 == 1) || (j/6 ==3))\n\t\t{\n\t\t\tvarf0 = 0.01;\n\t\t\tvarf1 = 0.01;\n\t\t}\n\t\tif (j/6 > 1)\n\t\t{\n\t\t\tQ1 = 1.0;\n\t\t}\n\t\tomegas << omega0, omega1;\n\t\tQpars << Q0, Q1;\n\t\tvarfs << varf0, varf1;\n\n\t\tomega_one << omega1;\n\t\tQpar_one << Q1;\n\t\tvarf_one << varf1;\n\n\t\t// Simulate a 2 component DSHO model\n\t\tgpstate::n_dsho::N_DSHOSolver ndsho(times,yi,yerr,omegas, Qpars, varfs);\n\t\tndsho.simulate_N_DSHO(y_sim, rng);\n\n\t\t// For efficiency, just output one of the components as well (the varying one)\n\t\tgpstate::n_dsho::N_DSHOSolver ndsho_one(times,yi,yerr,omega_one, Qpar_one, varf_one);\n\t\tndsho_one.simulate_N_DSHO(y_sim_one, rng);\n\n\t\t// write simulated vector to file GPtest.txt\n\t\tstd::ofstream file(\"GPtest\" + std::to_string(j+1) + \"_ndsho.txt\");\n\t\tassert(file.is_open());\n\t\tfile << \"# N_DSHO simulated light curve\" << endl;\n\t\tfile << \"# input parameters: \" << endl;\n\t\tfile << \"# omega: \" << omega0 << \", \" << omega1 << endl;\n\t\tfile << \"# Q: \" << Q0 << \", \" << Q1 << endl;\n\t\tfile << \"# varf: \" << varf0 << \", \" << varf1 << endl;\n\t\tfile << \"# time y_sim\" << endl;\n\t\tfor(int i=0; i\n#include \n\n#include \n#include \n\n#include \n#include \n\n\n// FASTSINCOS: 0 = slow native, 1 = gr::fxpt impl, 2 = sincostable.h\n#define FASTSINCOS 2\n\n\nnamespace gr {\n namespace channels {\n\n selective_fading_model::sptr\n selective_fading_model::make( unsigned int N, float fDTs, bool LOS, float K, int seed, std::vector delays, std::vector mags, int ntaps)\n {\n return gnuradio::get_initial_sptr\n\t(new selective_fading_model_impl( N, fDTs, LOS, K, seed, delays, mags, ntaps));\n }\n\n // Block constructor\n selective_fading_model_impl::selective_fading_model_impl( unsigned int N, float fDTs, bool LOS, float K, int seed, std::vector delays, std::vector mags, int ntaps )\n : sync_block(\"selective_fading_model\",\n\t\t io_signature::make(1, 1, sizeof(gr_complex)),\n\t\t io_signature::make(1, 1, sizeof(gr_complex))),\n d_delays(delays),\n d_mags(mags),\n d_sintable(1024)\n {\n if(mags.size() != delays.size())\n throw std::runtime_error(\"magnitude and delay vectors must be the same length!\");\n\n for(size_t i=0; i= 1\"); }\n set_history(1+ntaps);\n d_taps.resize(ntaps, gr_complex(0,0));\n }\n\n selective_fading_model_impl::~selective_fading_model_impl()\n {\n for(size_t i=0; inext_sample());\n for(size_t k=0; k(\n alias(), \"fDTs\",\n &selective_fading_model::fDTs,\n pmt::mp(0), pmt::mp(1), pmt::mp(0.01),\n \"Hz*Sec\", \"normalized maximum doppler frequency (fD*Ts)\",\n RPC_PRIVLVL_MIN, DISPTIME | DISPOPTSTRIP)));\n add_rpc_variable(\n rpcbasic_sptr(new rpcbasic_register_set(\n alias(), \"fDTs\",\n &selective_fading_model::set_fDTs,\n pmt::mp(0), pmt::mp(1), pmt::mp(0.01),\n \"Hz*Sec\", \"normalized maximum doppler frequency (fD*Ts)\",\n RPC_PRIVLVL_MIN, DISPTIME | DISPOPTSTRIP)));\n\n add_rpc_variable(\n rpcbasic_sptr(new rpcbasic_register_get(\n alias(), \"K\",\n &selective_fading_model::K,\n pmt::mp(0), pmt::mp(8), pmt::mp(4),\n \"Ratio\", \"Rician factor (ratio of the specular power to the scattered power)\",\n RPC_PRIVLVL_MIN, DISPTIME | DISPOPTSTRIP)));\n add_rpc_variable(\n rpcbasic_sptr(new rpcbasic_register_set(\n alias(), \"K\",\n &selective_fading_model::set_K,\n pmt::mp(0), pmt::mp(8), pmt::mp(4),\n \"Ratio\", \"Rician factor (ratio of the specular power to the scattered power)\",\n RPC_PRIVLVL_MIN, DISPTIME | DISPOPTSTRIP)));\n\n add_rpc_variable(\n rpcbasic_sptr(new rpcbasic_register_get(\n alias(), \"step\",\n &selective_fading_model::step,\n pmt::mp(0), pmt::mp(8), pmt::mp(4),\n \"radians\", \"Maximum step size for random walk angle per sample\",\n RPC_PRIVLVL_MIN, DISPTIME | DISPOPTSTRIP)));\n add_rpc_variable(\n rpcbasic_sptr(new rpcbasic_register_set(\n alias(), \"step\",\n &selective_fading_model::set_step,\n pmt::mp(0), pmt::mp(1), pmt::mp(0.00001),\n \"radians\", \"Maximum step size for random walk angle per sample\",\n RPC_PRIVLVL_MIN, DISPTIME | DISPOPTSTRIP)));\n#endif /* GR_CTRLPORT */\n }\n\n } /* namespace channels */\n} /* namespace gr */\n", "meta": {"hexsha": "3594ec4aa0c8d50792d951e0e0a72aecb2ac516f", "size": 6224, "ext": "cc", "lang": "C++", "max_stars_repo_path": "gnuradio-3.7.13.4/gr-channels/lib/selective_fading_model_impl.cc", "max_stars_repo_name": "v1259397/cosmic-gnuradio", "max_stars_repo_head_hexsha": "64c149520ac6a7d44179c3f4a38f38add45dd5dc", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-03-09T07:32:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-09T07:32:37.000Z", "max_issues_repo_path": "gnuradio-3.7.13.4/gr-channels/lib/selective_fading_model_impl.cc", "max_issues_repo_name": "v1259397/cosmic-gnuradio", "max_issues_repo_head_hexsha": "64c149520ac6a7d44179c3f4a38f38add45dd5dc", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gnuradio-3.7.13.4/gr-channels/lib/selective_fading_model_impl.cc", "max_forks_repo_name": "v1259397/cosmic-gnuradio", "max_forks_repo_head_hexsha": "64c149520ac6a7d44179c3f4a38f38add45dd5dc", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.6117647059, "max_line_length": 182, "alphanum_fraction": 0.6110218509, "num_tokens": 1648, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6959583250334526, "lm_q2_score": 0.5, "lm_q1q2_score": 0.3479791625167263}} {"text": "#include \"CALPHADFreeEnergyFunctionsBinary.h\"\n#include \"CALPHADConcSolverBinary.h\"\n#include \"CALPHADEqConcSolverBinary.h\"\n#include \"CALPHADFunctions.h\"\n#include \"PhysicalConstants.h\"\n#include \"functions.h\"\n#include \"well_functions.h\"\n\n#include \n\n#include \n#include \n\nnamespace pt = boost::property_tree;\n\nnamespace Thermo4PFM\n{\n\nCALPHADFreeEnergyFunctionsBinary::CALPHADFreeEnergyFunctionsBinary(\n pt::ptree& calphad_db, boost::optional newton_db,\n const EnergyInterpolationType energy_interp_func_type,\n const ConcInterpolationType conc_interp_func_type)\n : energy_interp_func_type_(energy_interp_func_type),\n conc_interp_func_type_(conc_interp_func_type),\n newton_tol_(1.e-8),\n newton_alpha_(1.),\n newton_maxits_(20),\n newton_verbose_(false)\n{\n std::string fenergy_diag_filename(\"energy.vtk\");\n fenergy_diag_filename_ = new char[fenergy_diag_filename.length() + 1];\n strcpy(fenergy_diag_filename_, fenergy_diag_filename.c_str());\n\n readParameters(calphad_db);\n\n if (newton_db) readNewtonparameters(newton_db.get());\n}\n\n//=======================================================================\n\nvoid CALPHADFreeEnergyFunctionsBinary::readNewtonparameters(\n pt::ptree& newton_db)\n{\n newton_tol_ = newton_db.get(\"tol\", newton_tol_);\n newton_alpha_ = newton_db.get(\"alpha\", newton_alpha_);\n newton_maxits_ = newton_db.get(\"max_its\", newton_maxits_);\n newton_verbose_ = newton_db.get(\"verbose\", newton_verbose_);\n}\n\n//=======================================================================\n\nvoid CALPHADFreeEnergyFunctionsBinary::readParameters(pt::ptree& calphad_db)\n{\n pt::ptree& species0_db = calphad_db.get_child(\"SpeciesA\");\n std::string dbnameL(\"PhaseL\");\n g_species_phaseL_[0].initialize(\"L0\", species0_db.get_child(dbnameL));\n std::string dbnameA(\"PhaseA\");\n g_species_phaseA_[0].initialize(\"A0\", species0_db.get_child(dbnameA));\n\n pt::ptree& speciesB_db = calphad_db.get_child(\"SpeciesB\");\n g_species_phaseL_[1].initialize(\"L1\", speciesB_db.get_child(dbnameL));\n g_species_phaseA_[1].initialize(\"A1\", speciesB_db.get_child(dbnameA));\n\n // read Lmix coefficients\n std::string dbnamemixL(\"LmixPhaseL\");\n pt::ptree Lmix0_db = calphad_db.get_child(dbnamemixL);\n readLmixBinary(Lmix0_db, LmixPhaseL_);\n\n std::string dbnamemixA(\"LmixPhaseA\");\n pt::ptree Lmix1_db = calphad_db.get_child(dbnamemixA);\n readLmixBinary(Lmix1_db, LmixPhaseA_);\n\n // print database just read\n // std::clog << \"CALPHAD database...\" << std::endl;\n // pt::write_json(std::clog, calphad_db);\n}\n\n//-----------------------------------------------------------------------\n#ifdef HAVE_OPENMP_OFFLOAD\n#pragma omp declare target\n#endif\n\ndouble CALPHADFreeEnergyFunctionsBinary::computeFreeEnergy(\n const double temperature, const double* const conc, const PhaseIndex pi,\n const bool gp)\n{\n const CalphadDataType l0 = lmixPhase(0, pi, temperature);\n const CalphadDataType l1 = lmixPhase(1, pi, temperature);\n const CalphadDataType l2 = lmixPhase(2, pi, temperature);\n const CalphadDataType l3 = lmixPhase(3, pi, temperature);\n\n CALPHADSpeciesPhaseGibbsEnergy* g_species;\n\n switch (pi)\n {\n case PhaseIndex::phaseL:\n g_species = &g_species_phaseL_[0];\n break;\n case PhaseIndex::phaseA:\n g_species = &g_species_phaseA_[0];\n break;\n default:\n // std::cerr << \"CALPHADFreeEnergyFunctionsBinary::\"\n // \"computeFreeEnergy(), undefined phase\"\n // << \"!!!\" << std::endl;\n // abort();\n return 0.;\n }\n\n double fe = conc[0] * g_species[0].fenergy(temperature)\n + (1. - conc[0]) * g_species[1].fenergy(temperature)\n + CALPHADcomputeFMixBinary(l0, l1, l2, l3, conc[0])\n + CALPHADcomputeFIdealMixBinary(\n gas_constant_R_JpKpmol * temperature, conc[0]);\n\n // subtract -mu*c to get grand potential\n if (gp)\n {\n double deriv;\n computeDerivFreeEnergy(temperature, conc, pi, &deriv);\n fe -= deriv * conc[0];\n }\n\n return fe;\n}\n\n//=======================================================================\n\nvoid CALPHADFreeEnergyFunctionsBinary::computeDerivFreeEnergy(\n const double temperature, const double* const conc, const PhaseIndex pi,\n double* deriv)\n{\n const CalphadDataType l0 = lmixPhase(0, pi, temperature);\n const CalphadDataType l1 = lmixPhase(1, pi, temperature);\n const CalphadDataType l2 = lmixPhase(2, pi, temperature);\n const CalphadDataType l3 = lmixPhase(3, pi, temperature);\n\n CALPHADSpeciesPhaseGibbsEnergy* g_species;\n\n switch (pi)\n {\n case PhaseIndex::phaseL:\n g_species = &g_species_phaseL_[0];\n break;\n case PhaseIndex::phaseA:\n g_species = &g_species_phaseA_[0];\n break;\n default:\n // std::cerr << \"CALPHADFreeEnergyFunctionsBinary::\"\n // \"computeFreeEnergy(), undefined phase!!!\"\n // << std::endl;\n // abort();\n return;\n }\n\n double mu = (g_species[0].fenergy(temperature)\n - g_species[1].fenergy(temperature))\n + CALPHADcomputeFMix_derivBinary(l0, l1, l2, l3, conc[0])\n + CALPHADcomputeFIdealMix_derivBinary(\n gas_constant_R_JpKpmol * temperature, conc[0]);\n\n deriv[0] = mu;\n}\n\n//=======================================================================\n\nvoid CALPHADFreeEnergyFunctionsBinary::computeSecondDerivativeFreeEnergy(\n const double temp, const double* const conc, const PhaseIndex pi,\n double* d2fdc2)\n{\n // assert(conc[0] >= 0.);\n // assert(conc[0] <= 1.);\n\n const CalphadDataType l0 = lmixPhase(0, pi, temp);\n const CalphadDataType l1 = lmixPhase(1, pi, temp);\n const CalphadDataType l2 = lmixPhase(2, pi, temp);\n const CalphadDataType l3 = lmixPhase(3, pi, temp);\n const double rt = gas_constant_R_JpKpmol * temp;\n\n d2fdc2[0] = (CALPHADcomputeFMix_deriv2Binary(l0, l1, l2, l3, conc[0])\n + CALPHADcomputeFIdealMix_deriv2Binary(rt, conc[0]));\n}\n\n//=======================================================================\n\nvoid CALPHADFreeEnergyFunctionsBinary::computeTdependentParameters(\n const double temperature, CalphadDataType* Lmix_L, CalphadDataType* Lmix_A,\n CalphadDataType* fA, CalphadDataType* fB)\n{\n fA[0] = g_species_phaseL_[0].fenergy(temperature);\n fB[0] = g_species_phaseL_[1].fenergy(temperature);\n Lmix_L[0] = lmixPhase(0, PhaseIndex::phaseL, temperature);\n Lmix_L[1] = lmixPhase(1, PhaseIndex::phaseL, temperature);\n Lmix_L[2] = lmixPhase(2, PhaseIndex::phaseL, temperature);\n Lmix_L[3] = lmixPhase(3, PhaseIndex::phaseL, temperature);\n\n fA[1] = g_species_phaseA_[0].fenergy(temperature);\n fB[1] = g_species_phaseA_[1].fenergy(temperature);\n Lmix_A[0] = lmixPhase(0, PhaseIndex::phaseA, temperature);\n Lmix_A[1] = lmixPhase(1, PhaseIndex::phaseA, temperature);\n Lmix_A[2] = lmixPhase(2, PhaseIndex::phaseA, temperature);\n Lmix_A[3] = lmixPhase(3, PhaseIndex::phaseA, temperature);\n}\n\n//=======================================================================\n\n// compute equilibrium concentrations in various phases for given temperature\nbool CALPHADFreeEnergyFunctionsBinary::computeCeqT(\n const double temperature, double* ceq, const int maxits, const bool verbose)\n{\n#ifndef HAVE_OPENMP_OFFLOAD\n if (verbose)\n std::cout << \"CALPHADFreeEnergyFunctionsBinary::computeCeqT()\"\n << std::endl;\n#endif\n // assert(temperature > 0.);\n\n // evaluate temperature dependent parameters\n CalphadDataType fA[3];\n CalphadDataType fB[3];\n\n CalphadDataType Lmix_L[4];\n CalphadDataType Lmix_A[4];\n\n computeTdependentParameters(temperature, Lmix_L, Lmix_A, fA, fB);\n\n double RTinv = 1.0 / (gas_constant_R_JpKpmol * temperature);\n\n CALPHADEqConcSolverBinary eq_solver;\n\n eq_solver.setup(RTinv, Lmix_L, Lmix_A, fA, fB);\n int ret = eq_solver.ComputeConcentration(ceq, newton_tol_, maxits);\n\n#ifndef HAVE_OPENMP_OFFLOAD\n if (ret >= 0)\n {\n if (verbose)\n {\n std::cout << \"CALPHAD, c_eq phase0=\" << ceq[0] << std::endl;\n std::cout << \"CALPHAD, c_eq phase1=\" << ceq[1] << std::endl;\n }\n }\n else\n {\n std::cout << \"CALPHADFreeEnergyFunctionsBinary, WARNING: ceq \"\n \"computation did not converge\"\n << std::endl;\n }\n#endif\n\n return (ret >= 0);\n}\n\n//=======================================================================\n\nvoid CALPHADFreeEnergyFunctionsBinary::computePhasesFreeEnergies(\n const double temperature, const double* const hphi, const double conc,\n double& fl, double& fa)\n{\n // std::cout<<\"CALPHADFreeEnergyFunctionsBinary::computePhasesFreeEnergies()\"<= 0.);\n fl = computeFreeEnergy(temperature, &c[0], PhaseIndex::phaseL, false);\n\n // assert(c[1] >= 0.);\n fa = computeFreeEnergy(temperature, &c[1], PhaseIndex::phaseA, false);\n}\n\n//-----------------------------------------------------------------------\n\nint CALPHADFreeEnergyFunctionsBinary::computePhaseConcentrations(\n const double temperature, const double* const conc, const double* const phi,\n double* x)\n{\n // assert(x[0] >= 0.);\n // assert(x[1] >= 0.);\n // assert(x[0] <= 1.);\n // assert(x[1] <= 1.);\n\n const double RTinv = 1.0 / (gas_constant_R_JpKpmol * temperature);\n\n CalphadDataType fA[2];\n CalphadDataType fB[2];\n CalphadDataType Lmix_L[4];\n CalphadDataType Lmix_A[4];\n\n computeTdependentParameters(temperature, Lmix_L, Lmix_A, fA, fB);\n\n const double hphi = interp_func(conc_interp_func_type_, phi[0]);\n\n // conc could be outside of [0.,1.] in a trial step\n double c0 = conc[0] >= 0. ? conc[0] : 0.;\n c0 = c0 <= 1. ? c0 : 1.;\n // solve system of equations to find (cl,cs) given c0 and hphi\n // x: initial guess and solution\n CALPHADConcSolverBinary solver;\n solver.setup(c0, hphi, RTinv, Lmix_L, Lmix_A, fA, fB);\n int ret = solver.ComputeConcentration(\n x, newton_tol_, newton_maxits_, newton_alpha_);\n#if 0\n if (ret == -1)\n {\n std::cerr << \"ERROR, \"\n \"CALPHADFreeEnergyFunctionsBinary::\"\n \"computePhaseConcentrations() \"\n \"failed for conc=\"\n << conc[0] << \", hphi=\" << hphi[0] << std::endl;\n abort();\n }\n#endif\n\n return ret;\n}\n#ifdef HAVE_OPENMP_OFFLOAD\n#pragma omp end declare target\n#endif\n\n//-----------------------------------------------------------------------\n\nvoid CALPHADFreeEnergyFunctionsBinary::energyVsPhiAndC(const double temperature,\n const double* const ceq, const bool found_ceq, const double phi_well_scale,\n const int npts_phi, const int npts_c)\n{\n std::cout << \"CALPHADFreeEnergyFunctionsBinary::energyVsPhiAndC()...\"\n << std::endl;\n\n double slopec = 0.;\n double fc0 = 0.;\n double fc1 = 0.;\n if (found_ceq)\n {\n // compute slope of f between equilibrium concentrations\n // to add slopec*conc to energy later on\n\n fc0 = computeFreeEnergy(temperature, &ceq[0], PhaseIndex::phaseL);\n fc1 = computeFreeEnergy(temperature, &ceq[1], PhaseIndex::phaseA);\n slopec = -(fc1 - fc0) / (ceq[1] - ceq[0]);\n }\n std::cout << std::setprecision(8) << \"fc0: \" << fc0 << \"...\"\n << \", fc1: \" << fc1 << \"...\" << std::endl;\n std::cout << \"CALPHADFreeEnergyFunctionsBinary: Use slope: \" << slopec\n << \"...\" << std::endl;\n\n // reset cmin, cmax, deltac\n double cmin = std::min(ceq[0], ceq[1]);\n double cmax = std::max(ceq[0], ceq[1]);\n double dc = cmax - cmin;\n cmin = std::max(0.25 * cmin, cmin - 0.25 * dc);\n cmax = std::min(1. - 0.25 * (1. - cmax), cmax + 0.25 * dc);\n cmax = std::max(cmax, cmin + dc);\n double deltac = (cmax - cmin) / (npts_c - 1);\n\n std::ofstream tfile(fenergy_diag_filename_, std::ios::out);\n\n printEnergyVsPhiHeader(\n temperature, npts_phi, npts_c, cmin, cmax, slopec, tfile);\n\n for (int i = 0; i < npts_c; i++)\n {\n double conc = cmin + deltac * i;\n printEnergyVsPhi(\n &conc, temperature, phi_well_scale, npts_phi, slopec, tfile);\n }\n}\n\n// Print out free energy as a function of phase\n// for given composition and temperature\n// File format: ASCII VTK, readble with Visit\nvoid CALPHADFreeEnergyFunctionsBinary::printEnergyVsPhiHeader(\n const double temperature, const int nphi, const int nc, const double cmin,\n const double cmax, const double slopec, std::ostream& os) const\n{\n os << \"# vtk DataFile Version 2.0\" << std::endl;\n os << \"Free energy + \" << slopec << \"*c [J/mol] at T=\" << temperature\n << std::endl;\n os << \"ASCII\" << std::endl;\n os << \"DATASET STRUCTURED_POINTS\" << std::endl;\n\n os << \"DIMENSIONS \" << nphi << \" \" << nc << \" 1\" << std::endl;\n double asp_ratio_c = (nc > 1) ? (cmax - cmin) / (nc - 1) : 1.;\n os << \"ASPECT_RATIO \" << 1. / (nphi - 1) << \" \" << asp_ratio_c << \" 1.\"\n << std::endl;\n os << \"ORIGIN 0. \" << cmin << \" 0.\" << std::endl;\n os << \"POINT_DATA \" << nphi * nc << std::endl;\n os << \"SCALARS energy float 1\" << std::endl;\n os << \"LOOKUP_TABLE default\" << std::endl;\n}\n\n//=======================================================================\n\nvoid CALPHADFreeEnergyFunctionsBinary::printEnergyVsPhi(\n const double* const conc, const double temperature,\n const double phi_well_scale, const int npts, const double slopec,\n std::ostream& os)\n{\n // std::cout << \"CALPHADFreeEnergyFunctionsBinary::printEnergyVsPhi()...\" <<\n // std::endl;\n const double dphi = 1.0 / (double)(npts - 1);\n\n // os << \"# phi f(phi) for c=\" << conc\n // << \" and T=\" << temperature << std::endl;\n for (int i = 0; i < npts; i++)\n {\n const double phi = i * dphi;\n\n double e = fchem(&phi, conc, temperature);\n const double w = phi_well_scale * well_func(phi);\n\n os << e + w + slopec * conc[0] << std::endl;\n }\n // os << std::endl;\n}\n\n//=======================================================================\n// compute free energy in [J/mol]\ndouble CALPHADFreeEnergyFunctionsBinary::fchem(\n const double* const phi, const double* const conc, const double temperature)\n{\n const double hcphi = interp_func(conc_interp_func_type_, phi[0]);\n\n const double tol = 1.e-8;\n double fl = 0.;\n double fa = 0.;\n double fb = 0.;\n if ((phi[0] > tol) & (phi[0] < (1. - tol)))\n {\n computePhasesFreeEnergies(temperature, &hcphi, conc[0], fl, fa);\n }\n else\n {\n if (phi[0] <= tol)\n {\n fl = computeFreeEnergy(temperature, conc, PhaseIndex::phaseL);\n }\n else\n {\n fa = computeFreeEnergy(temperature, conc, PhaseIndex::phaseA);\n }\n }\n\n const double hfphi = interp_func(energy_interp_func_type_, phi[0]);\n\n double e = (1.0 - hfphi) * fl + hfphi * fa;\n\n return e;\n}\n\n//=======================================================================\n\nvoid CALPHADFreeEnergyFunctionsBinary::printEnergyVsComposition(\n const double temperature, std::ostream& os, const int npts)\n{\n const double dc = 1.0 / (double)(npts - 1);\n\n os << \"#phi=0\" << std::endl;\n for (int i = 0; i < npts; i++)\n {\n const double conc = i * dc;\n\n const double phi = 0.0;\n\n double e = fchem(&phi, &conc, temperature);\n os << conc << \"\\t\" << e << std::endl;\n }\n os << std::endl << std::endl;\n\n os << \"#phi=1\" << std::endl;\n for (int i = 0; i < npts; i++)\n {\n const double conc = i * dc;\n\n const double phi = 1.0;\n\n double e = fchem(&phi, &conc, temperature);\n os << conc << \"\\t\" << e << std::endl;\n }\n}\n\n//=======================================================================\n\nvoid CALPHADFreeEnergyFunctionsBinary::preRunDiagnostics(\n const double T0, const double T1)\n{\n std::ofstream os1(\"FlC0vsT.dat\", std::ios::out);\n os1 << \"#Species 0, Phase L\" << std::endl;\n g_species_phaseL_[0].plotFofT(os1, T0, T1);\n\n std::ofstream os2(\"FlC1vsT.dat\", std::ios::out);\n os2 << \"#Species 1, Phase L\" << std::endl;\n g_species_phaseL_[1].plotFofT(os2, T0, T1);\n\n std::ofstream os3(\"FsC0vsT.dat\", std::ios::out);\n os3 << \"#Species 0, Phase A\" << std::endl;\n g_species_phaseA_[0].plotFofT(os3, T0, T1);\n\n std::ofstream os4(\"FsC1vsT.dat\", std::ios::out);\n os4 << \"#Species 1, Phase A\" << std::endl;\n g_species_phaseA_[1].plotFofT(os4, T0, T1);\n}\n}\n", "meta": {"hexsha": "6e7bfd1cc410982412f200c52cbe7ab207b41559", "size": 17847, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/CALPHADFreeEnergyFunctionsBinary.cc", "max_stars_repo_name": "stvdwtt/Thermo4PFM", "max_stars_repo_head_hexsha": "5308b7c58c4b67ed98d2bd50469226b7d89da2b8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/CALPHADFreeEnergyFunctionsBinary.cc", "max_issues_repo_name": "stvdwtt/Thermo4PFM", "max_issues_repo_head_hexsha": "5308b7c58c4b67ed98d2bd50469226b7d89da2b8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/CALPHADFreeEnergyFunctionsBinary.cc", "max_forks_repo_name": "stvdwtt/Thermo4PFM", "max_forks_repo_head_hexsha": "5308b7c58c4b67ed98d2bd50469226b7d89da2b8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.7372400756, "max_line_length": 88, "alphanum_fraction": 0.5837395641, "num_tokens": 4998, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6959583250334526, "lm_q2_score": 0.5, "lm_q1q2_score": 0.3479791625167263}} {"text": "/* ----------------------------------------------------------------------- *//**\n *\n * @file boost.hpp\n *\n *//* ----------------------------------------------------------------------- */\n\n#define LIST_CONTINUOUS_PROB_DISTR \\\n MADLIB_ITEM(beta) \\\n MADLIB_ITEM(cauchy) \\\n MADLIB_ITEM(chi_squared) \\\n MADLIB_ITEM(fisher_f) \\\n MADLIB_ITEM(exponential) \\\n MADLIB_ITEM(extreme_value) \\\n MADLIB_ITEM(gamma) \\\n MADLIB_ITEM(inverse_chi_squared) \\\n MADLIB_ITEM(inverse_gamma) \\\n MADLIB_ITEM(laplace) \\\n MADLIB_ITEM(logistic) \\\n MADLIB_ITEM(lognormal) \\\n MADLIB_ITEM(non_central_beta) \\\n MADLIB_ITEM(non_central_chi_squared) \\\n MADLIB_ITEM(non_central_f) \\\n MADLIB_ITEM(non_central_t) \\\n MADLIB_ITEM(normal) \\\n MADLIB_ITEM(pareto) \\\n MADLIB_ITEM(rayleigh) \\\n MADLIB_ITEM(triangular) \\\n MADLIB_ITEM(uniform) \\\n MADLIB_ITEM(weibull)\n// FIXME: MADLIB-513: Pending Boost bug 6934, we currently do not support the\n// inverse Gaussian distribution. https://svn.boost.org/trac/boost/ticket/6934\n// MADLIB_ITEM(inverse_gaussian)\n// For Student's t distribution, see student.hpp\n\n\n#define LIST_DISCRETE_PROB_DISTR \\\n MADLIB_ITEM(bernoulli) \\\n MADLIB_ITEM(binomial) \\\n MADLIB_ITEM(geometric) \\\n MADLIB_ITEM(hypergeometric) \\\n MADLIB_ITEM(negative_binomial) \\\n MADLIB_ITEM(poisson)\n\n\n#define MADLIB_ITEM(dist) \\\n DECLARE_UDF(prob, dist ## _cdf) \\\n DECLARE_UDF(prob, dist ## _pdf) \\\n DECLARE_UDF(prob, dist ## _quantile)\n\nLIST_CONTINUOUS_PROB_DISTR\n\n#undef MADLIB_ITEM\n\n#define MADLIB_ITEM(dist) \\\n DECLARE_UDF(prob, dist ## _cdf) \\\n DECLARE_UDF(prob, dist ## _pmf) \\\n DECLARE_UDF(prob, dist ## _quantile)\n\nLIST_DISCRETE_PROB_DISTR\n\n#undef MADLIB_ITEM\n\n\n#ifndef MADLIB_MODULES_PROB_BOOST_HPP\n#define MADLIB_MODULES_PROB_BOOST_HPP\n\n#include \n\nnamespace madlib {\n\nnamespace modules {\n\nnamespace prob {\n\nnamespace {\n// No need to make this visable beyond this translation unit.\n\nenum ProbFnOverride {\n kResultIsReady = 0,\n kLetBoostCalculate,\n kLetBoostCalculateUsingValue\n};\n\n/**\n * @brief Via (partial) specialization, this class offers a way to override\n * boost's domain checks\n *\n * Some boost functions have domain checks we would like to override. E.g.,\n * boost's CDF and PDF for the Fisher F-distribution raise a domain error if the\n * input argument is <0 or infinity. By using madlib::modules::prob::cdf() (and\n * pdf/quantile, respectively), these domain checks can be overridden.\n * In MADlib, we always prefer returning correct values as opposed to raising\n * errors. E.g., for the CDF, it is the correct mathematical behavior to simply\n * return 0 if the input argument for the Fisher F-distribution is < 0.\n *\n * The following functions return \\c true if boost's implementation should be\n * called, and they return \\c false if the function result has alrady been\n * stored in \\c outResult and boost's implementation should not be called any\n * more.\n *\n * Note that C++03 does not support partial specialization of functions. We\n * therefore must partially specialize the whole \\c DomainCheck class.\n */\ntemplate \nstruct DomainCheck {\n typedef typename Distribution::value_type RealType;\n\n template \n static ProbFnOverride cdf(const Distribution&, const RealType&, RealType&) {\n return kLetBoostCalculate;\n }\n\n static ProbFnOverride pdf(const Distribution&, const RealType&, RealType&) {\n return kLetBoostCalculate;\n }\n\n template \n static ProbFnOverride quantile(const Distribution&, const RealType&,\n RealType&) {\n\n return kLetBoostCalculate;\n }\n};\n\n/**\n * @brief Domain-check overrides for distribution functions with support in\n * \\f$ \\mathbb R \\f$\n *\n * We override the domain check by treating -infinity and infinity as part of\n * the domain. Some, but not all, boost functions would raise a domain_error\n * instead. See:\n * http://www.boost.org/doc/libs/1_49_0/libs/math/doc/sf_and_dist/html/math_toolkit/backgrounders/implementation.html#math_toolkit.backgrounders.implementation.handling_of_floating_point_infinity\n */\ntemplate \nstruct RealDomainCheck {\n typedef typename Distribution::value_type RealType;\n\n template \n static ProbFnOverride cdf(const Distribution&, const RealType& inX,\n RealType& outResult) {\n\n if (boost::math::isinf(inX)) {\n if (inX < 0)\n outResult = Complement ? 1 : 0;\n else\n outResult = Complement ? 0 : 1;\n return kResultIsReady;\n }\n return kLetBoostCalculate;\n }\n\n static ProbFnOverride pdf(const Distribution&, const RealType& inX,\n RealType& outResult) {\n\n if (boost::math::isinf(inX)) {\n outResult = 0;\n return kResultIsReady;\n }\n return kLetBoostCalculate;\n }\n\n template \n static ProbFnOverride quantile(const Distribution&, const RealType&, RealType&) {\n return kLetBoostCalculate;\n }\n};\n\n/**\n * @brief Domain-check overrides for distribution functions with support in\n * \\f$ [0, \\infty) \\f$\n */\ntemplate \nstruct PositiveDomainCheck : public RealDomainCheck {\n typedef RealDomainCheck Base;\n typedef typename Base::RealType RealType;\n\n template \n static ProbFnOverride cdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n if (inX < 0) {\n outResult = Complement ? 1 : 0;\n return kResultIsReady;\n }\n return Base::template cdf(inDist, inX, outResult);\n }\n\n static ProbFnOverride pdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n if (inX < 0) {\n outResult = 0;\n return kResultIsReady;\n }\n return Base::pdf(inDist, inX, outResult);\n }\n};\n\n/**\n * @brief Domain-check overrides for distribution functions with support in\n * \\f$ [0, 1] \\f$\n */\ntemplate \nstruct ZeroOneDomainCheck : public PositiveDomainCheck {\n typedef PositiveDomainCheck Base;\n typedef typename Base::RealType RealType;\n\n template \n static ProbFnOverride cdf(const Distribution&, const RealType& inX,\n RealType& outResult) {\n\n if (inX < 0)\n outResult = Complement ? 1 : 0;\n else if (inX > 1)\n outResult = Complement ? 0 : 1;\n else\n return kLetBoostCalculate;\n\n return kResultIsReady;\n }\n\n static ProbFnOverride pdf(const Distribution&, const RealType& inX,\n RealType& outResult) {\n\n if (inX < 0 || inX > 1) {\n outResult = 0;\n return kResultIsReady;\n }\n return kLetBoostCalculate;\n }\n};\n\n/**\n * @brief Domain-check overrides for distribution functions with support in\n * \\f$ \\mathbb Z \\f$\n */\ntemplate \nstruct IntegerDomainCheck : public RealDomainCheck {\n typedef RealDomainCheck Base;\n typedef typename Base::RealType RealType;\n\n static ProbFnOverride internalMakeIntegral(ProbFnOverride inAction,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"IntegerDomainCheck::internalMakeIntegral(...)\";\n\n if (inAction != kResultIsReady) {\n if (std::isnan(inX)) {\n outResult = boost::math::policies::raise_domain_error(\n function,\n \"Random variate must be integral but was: %1%.\",\n inX,\n typename Distribution::policy_type());\n inAction = kResultIsReady;\n } else {\n outResult = std::floor(inX);\n inAction = kLetBoostCalculateUsingValue;\n }\n }\n return inAction;\n }\n\n template \n static ProbFnOverride cdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n return internalMakeIntegral(\n Base::template cdf(inDist, inX, outResult), inX,\n outResult);\n }\n\n static ProbFnOverride pdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n return internalMakeIntegral(\n Base::pdf(inDist, inX, outResult), inX, outResult);\n }\n};\n\n/**\n * @brief Domain-check overrides for distribution functions with support in\n * \\f$ \\mathbb N_0 \\f$\n */\ntemplate \nstruct NonNegativeIntegerDomainCheck : public IntegerDomainCheck {\n typedef IntegerDomainCheck Base;\n typedef typename Base::RealType RealType;\n\n template \n static ProbFnOverride cdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n if (inX < 0) {\n outResult = Complement ? 1 : 0;\n return kResultIsReady;\n }\n return Base::template cdf(inDist, inX, outResult);\n }\n\n static ProbFnOverride pdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n if (inX < 0) {\n outResult = 0;\n return kResultIsReady;\n }\n return Base::pdf(inDist, inX, outResult);\n }\n};\n\n\n/**\n * @brief Boost only accepts 0 or 1 for random variate\n *\n * Due to boost bug 6937, we also need to override the domain check for quantile\n *\n * https://svn.boost.org/trac/boost/ticket/6937\n */\ntemplate \nstruct DomainCheck >\n : public IntegerDomainCheck<\n boost::math::bernoulli_distribution\n > {\n typedef boost::math::bernoulli_distribution Distribution;\n typedef IntegerDomainCheck Base;\n\n template \n static ProbFnOverride cdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n if (inX < 0)\n outResult = Complement ? 1 : 0;\n else if (inX > 1)\n outResult = Complement ? 0 : 1;\n else\n return Base::template cdf(inDist, inX, outResult);\n\n return kResultIsReady;\n }\n\n static ProbFnOverride pdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n if (inX < 0 || inX > 1) {\n outResult = 0;\n return kResultIsReady;\n } else\n return Base::pdf(inDist, inX, outResult);\n }\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (!boost::math::detail::check_probability(function,\n inDist.success_fraction(), &outResult, Policy())) {\n return kResultIsReady;\n } else if (inP == 1 || inP == 0){\n outResult = inP;\n return kResultIsReady;\n } else {\n return Base::template quantile(inDist, inP, outResult);\n }\n }\n};\n\n/**\n * @brief Boost only accepts a limited range for random variates\n *\n * Due to boost bug 6937, we also need to override the domain check for quantile\n *\n * https://svn.boost.org/trac/boost/ticket/6937\n */\ntemplate \nstruct DomainCheck >\n : public IntegerDomainCheck<\n boost::math::binomial_distribution\n > {\n typedef boost::math::binomial_distribution Distribution;\n typedef IntegerDomainCheck Base;\n\n template \n static ProbFnOverride cdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::cdf(...)\";\n\n if (!boost::math::binomial_detail::check_dist(function, inDist.trials(),\n inDist.success_fraction(), &outResult, Policy())) {\n return kResultIsReady;\n } else if (inX < 0) {\n outResult = Complement ? 1 : 0;\n return kResultIsReady;\n } else if (inX > inDist.trials()) {\n outResult = Complement ? 0 : 1;\n return kResultIsReady;\n }\n return Base::template cdf(inDist, inX, outResult);\n }\n\n static ProbFnOverride pdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::pdf(...)\";\n\n if (!boost::math::binomial_detail::check_dist(function, inDist.trials(),\n inDist.success_fraction(), &outResult, Policy())) {\n return kResultIsReady;\n } else if (inX < 0 || inX > inDist.trials()) {\n outResult = 0;\n return kResultIsReady;\n }\n return Base::pdf(inDist, inX, outResult);\n }\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (!boost::math::binomial_detail::check_dist(function, inDist.trials(),\n inDist.success_fraction(), &outResult, Policy())\n || !boost::math::detail::check_probability(function, inP,\n &outResult, Policy())) {\n return kResultIsReady;\n } else if (inP == 1) {\n outResult = inDist.trials();\n return kResultIsReady;\n } else if (inP == 0) {\n outResult = 0;\n return kResultIsReady;\n } else if (inDist.success_fraction() == 1) {\n outResult = inDist.trials();\n return kResultIsReady;\n } else if (inDist.success_fraction() == 0) {\n outResult = 0;\n return kResultIsReady;\n }\n return Base::template quantile(inDist, inP, outResult);\n }\n};\n\n/**\n * @brief Due to boost bug XXX, we need to override the domain checks\n *\n * FIXME: No boost bug filed so far\n * Boost does not catch the case where lambda is non-finite.\n */\ntemplate \nstruct DomainCheck >\n : public PositiveDomainCheck<\n boost::math::exponential_distribution\n > {\n typedef boost::math::exponential_distribution Distribution;\n typedef PositiveDomainCheck Base;\n\n static bool check_dist(const char* function, RealType lambda,\n RealType* result, const Policy& pol) {\n\n if (!boost::math::isfinite(lambda)) {\n *result = boost::math::policies::raise_domain_error(\n function,\n \"The scale parameter \\\"lambda\\\" must be finite, but was: %1%.\",\n lambda, pol);\n return false;\n }\n return true;\n }\n\n template \n static ProbFnOverride cdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::cdf(...)\";\n\n if (!check_dist(function, inDist.lambda(), &outResult, Policy()))\n return kResultIsReady;\n return Base::template cdf(inDist, inX, outResult);\n }\n\n static ProbFnOverride pdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::pdf(...)\";\n\n if (!check_dist(function, inDist.lambda(), &outResult, Policy()))\n return kResultIsReady;\n return Base::pdf(inDist, inX, outResult);\n }\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (!check_dist(function, inDist.lambda(), &outResult, Policy()))\n return kResultIsReady;\n return Base::template quantile(inDist, inP, outResult);\n }\n};\n\n/**\n * @brief Due to boost bug XXX, we need to override the domain check for\n * quantile\n *\n * FIXME: No boost bug filed so far\n * Boost does not catch the case where the location or scale parameters are\n * non-finite.\n */\ntemplate \nstruct DomainCheck >\n : public RealDomainCheck<\n boost::math::extreme_value_distribution\n > {\n typedef boost::math::extreme_value_distribution Distribution;\n typedef RealDomainCheck Base;\n\n static bool check_dist(const char* function, RealType location,\n RealType scale, RealType* result, const Policy& pol) {\n\n return\n boost::math::detail::check_location(function, location, result, pol)\n && boost::math::detail::check_scale(function, scale, result, pol);\n }\n\n template \n static ProbFnOverride cdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::cdf(...)\";\n\n if (!check_dist(function, inDist.location(), inDist.scale(), &outResult,\n Policy()))\n return kResultIsReady;\n return Base::template cdf(inDist, inX, outResult);\n }\n\n static ProbFnOverride pdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::pdf(...)\";\n\n if (!check_dist(function, inDist.location(), inDist.scale(), &outResult,\n Policy()))\n return kResultIsReady;\n return Base::pdf(inDist, inX, outResult);\n }\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (!check_dist(function, inDist.location(), inDist.scale(), &outResult,\n Policy()))\n return kResultIsReady;\n return Base::template quantile(inDist, inP, outResult);\n }\n};\n\n/**\n * @brief Due to boost bug 6937, we need to override the domain check for\n * quantile\n *\n * https://svn.boost.org/trac/boost/ticket/6937\n */\ntemplate \nstruct DomainCheck >\n : public PositiveDomainCheck<\n boost::math::fisher_f_distribution\n > {\n typedef boost::math::fisher_f_distribution Distribution;\n typedef PositiveDomainCheck Base;\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (!boost::math::detail::check_df(function,\n inDist.degrees_of_freedom1(), &outResult, Policy())\n || !boost::math::detail::check_df(function,\n inDist.degrees_of_freedom2(), &outResult, Policy()))\n return kResultIsReady;\n\n if (std::isnan(inP)) {\n outResult = boost::math::policies::raise_domain_error(\n function,\n \"Probability argument is %1%, but must be >= 0 and <= 1!\", inP,\n Policy());\n return kResultIsReady;\n }\n return Base::template quantile(inDist, inP, outResult);\n }\n};\n\n/**\n * @brief Due to boost bug XXXX, we override the domain check for gamma: pdf\n *\n * For the gamma distribution, boost's pdf always returns 0 for x = 0. That is\n * wrong.\n */\ntemplate \nstruct DomainCheck >\n : public PositiveDomainCheck<\n boost::math::gamma_distribution\n > {\n typedef boost::math::gamma_distribution Distribution;\n typedef PositiveDomainCheck Base;\n\n static ProbFnOverride pdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::pdf(...)\";\n RealType shape = inDist.shape();\n RealType scale = inDist.scale();\n if (!boost::math::detail::check_gamma(function, scale, shape,\n &outResult, Policy()))\n return kResultIsReady;\n\n if (inX == 0) {\n if (shape == 1)\n outResult = 1. / scale;\n else if (shape < 1)\n outResult\n = boost::math::policies::raise_overflow_error(\n function, 0, Policy());\n else\n return kLetBoostCalculate;\n\n return kResultIsReady;\n }\n return Base::pdf(inDist, inX, outResult);\n }\n};\n\n/**\n * @brief Due to boost bug 6937, we need to override the domain check for\n * quantile\n *\n * https://svn.boost.org/trac/boost/ticket/6937\n */\ntemplate \nstruct DomainCheck >\n : public NonNegativeIntegerDomainCheck<\n boost::math::geometric_distribution\n > {\n typedef boost::math::geometric_distribution Distribution;\n typedef NonNegativeIntegerDomainCheck Base;\n\n template \n static ProbFnOverride cdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n if (inDist.success_fraction() == 1 && !std::isnan(inX)) {\n if (inX < 0)\n outResult = Complement ? 1 : 0;\n else if (inX > 0)\n outResult = Complement ? 0 : 1;\n else /* if (inX == 0) */\n outResult = 1;\n return kResultIsReady;\n }\n return Base::template cdf(inDist, inX, outResult);\n }\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (!boost::math::detail::check_probability(function,\n inDist.success_fraction(), &outResult, Policy()))\n return kResultIsReady;\n\n return Base::template quantile(inDist, inP, outResult);\n }\n};\n\n\n/**\n * @brief Boost only accepts a limited range for random variates\n */\ntemplate \nstruct DomainCheck >\n : public NonNegativeIntegerDomainCheck<\n boost::math::hypergeometric_distribution\n > {\n typedef boost::math::hypergeometric_distribution Distribution;\n typedef NonNegativeIntegerDomainCheck Base;\n\n template \n static ProbFnOverride cdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n // inDist's parameters are all unsigned, so we need to be careful in the\n // comparison!\n if (inX + inDist.total() < inDist.defective() + inDist.sample_count())\n outResult = Complement ? 1 : 0;\n else if (inX > inDist.sample_count() || inX > inDist.defective())\n outResult = Complement ? 0 : 1;\n else\n return Base::template cdf(inDist, inX, outResult);\n\n return kResultIsReady;\n }\n\n static ProbFnOverride pdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n // inDist's parameters are all unsigned, so we need to be careful in the\n // comparison!\n if (inX + inDist.total() < inDist.defective() + inDist.sample_count()\n || inX > inDist.sample_count() || inX > inDist.defective()) {\n outResult = 0;\n return kResultIsReady;\n } else\n return Base::pdf(inDist, inX, outResult);\n }\n};\n\n\n/**\n * @brief Boost returns a small non-zero value for quantile(0) instead of 0\n */\ntemplate \nstruct DomainCheck >\n : public PositiveDomainCheck<\n boost::math::inverse_gamma_distribution\n > {\n typedef boost::math::inverse_gamma_distribution Distribution;\n typedef PositiveDomainCheck Base;\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if(!boost::math::detail::check_inverse_gamma(function, inDist.scale(),\n inDist.shape(), &outResult, Policy()))\n return kResultIsReady;\n else if (inP == 0) {\n outResult = 0;\n return kResultIsReady;\n }\n return Base::template quantile(inDist, inP, outResult);\n }\n};\n\n/**\n * @brief Due to boost bug XXX, we need to override the domain check for\n * quantile\n *\n * FIXME: No boost bug filed so far\n * Boost does not catch the case where location or scale are not finite.\n */\ntemplate \nstruct DomainCheck >\n : public PositiveDomainCheck<\n boost::math::lognormal_distribution\n > {\n typedef boost::math::lognormal_distribution Distribution;\n typedef PositiveDomainCheck Base;\n\n static bool check_dist(const char* function, RealType location,\n RealType scale, RealType* result, const Policy& pol) {\n\n if (!boost::math::detail::check_location(function, location, result,\n pol)\n || !boost::math::detail::check_scale(function, scale, result, pol))\n return false;\n return true;\n }\n\n static ProbFnOverride pdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::pdf(...)\";\n\n if (!check_dist(function, inDist.location(), inDist.scale(), &outResult,\n Policy()))\n return kResultIsReady;\n return Base::pdf(inDist, inX, outResult);\n }\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (!check_dist(function, inDist.location(), inDist.scale(), &outResult,\n Policy()))\n return kResultIsReady;\n return Base::template quantile(inDist, inP, outResult);\n }\n};\n\n/**\n * @brief Due to boost bug 6937, we need to override the domain check for\n * quantile.\n *\n * https://svn.boost.org/trac/boost/ticket/6937\n *\n * Also, we want to raise an error if the success probability is 0, because the\n * distribution is not well-defined in that case.\n */\ntemplate \nstruct DomainCheck >\n : public NonNegativeIntegerDomainCheck<\n boost::math::negative_binomial_distribution\n > {\n typedef boost::math::negative_binomial_distribution Distribution;\n typedef NonNegativeIntegerDomainCheck Base;\n\n static bool check_dist(const char* function, const RealType& r,\n const RealType& p, RealType* result, const Policy& pol) {\n\n if (!boost::math::negative_binomial_detail::check_dist(function, r, p,\n result, pol)) {\n return false;\n } else if (p == 0) {\n *result = boost::math::policies::raise_domain_error(\n function,\n \"Probability argument is %1%, but must be > 0 and <= 1!\",\n p, pol);\n return false;\n }\n return true;\n }\n\n template \n static ProbFnOverride cdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::cdf(...)\";\n\n if (!check_dist(function, inDist.successes(), inDist.success_fraction(),\n &outResult, Policy()))\n return kResultIsReady;\n return Base::template cdf(inDist, inX, outResult);\n }\n\n static ProbFnOverride pdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::pdf(...)\";\n\n if (!check_dist(function, inDist.successes(), inDist.success_fraction(),\n &outResult, Policy()))\n return kResultIsReady;\n return Base::pdf(inDist, inX, outResult);\n }\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (!check_dist(function, inDist.successes(), inDist.success_fraction(),\n &outResult, Policy())) {\n return kResultIsReady;\n } else if (inDist.success_fraction() == 1) {\n // distribution is single-point measure, i.e., same for complement\n outResult = 0;\n return kResultIsReady;\n }\n return Base::template quantile(inDist, inP, outResult);\n }\n};\n\n/**\n * @brief Due to boost bug XXX, we need to check the corner cases for the pdf\n *\n * FIXME: No boost bug filed so far\n */\ntemplate \nstruct DomainCheck >\n : public ZeroOneDomainCheck<\n boost::math::non_central_beta_distribution\n > {\n typedef boost::math::non_central_beta_distribution Distribution;\n typedef ZeroOneDomainCheck Base;\n\n static ProbFnOverride pdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (inX == 0 || inX == 1) {\n if(!boost::math::beta_detail::check_alpha(function, inDist.alpha(),\n &outResult, Policy())\n || !boost::math::beta_detail::check_beta(function,\n inDist.beta(), &outResult, Policy())\n || !boost::math::detail::check_non_centrality(function,\n inDist.non_centrality(), &outResult, Policy()))\n return kResultIsReady;\n\n if (inX == 0) {\n if (inDist.alpha() < 1)\n outResult = boost::math::policies\n ::raise_overflow_error(function, 0, Policy());\n else if (inDist.alpha() == 1)\n outResult = inDist.beta()\n * std::exp(-inDist.non_centrality()/2.);\n else /* if (inDist.alpha() > 1) */\n outResult = 0;\n return kResultIsReady;\n } else /* if (inX == 1) */ {\n if (inDist.beta() < 1)\n outResult = boost::math::policies\n ::raise_overflow_error(function, 0, Policy());\n else if (inDist.beta() == 1)\n outResult = inDist.alpha() + inDist.non_centrality()/2.;\n else /* if (inDist.beta() > 1) */\n outResult = 0;\n return kResultIsReady;\n }\n }\n return Base::pdf(inDist, inX, outResult);\n }\n};\n\n/**\n * @brief Due to boost bug XXX, we need to check the corner cases for the pdf\n *\n * FIXME: No boost bug filed so far\n */\ntemplate \nstruct DomainCheck >\n : public PositiveDomainCheck<\n boost::math::non_central_chi_squared_distribution\n > {\n typedef boost::math::non_central_chi_squared_distribution Distribution;\n typedef PositiveDomainCheck Base;\n\n static ProbFnOverride pdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (inX == 0) {\n if(!boost::math::detail::check_df(function,\n inDist.degrees_of_freedom(), &outResult, Policy())\n || !boost::math::detail::check_non_centrality(function,\n inDist.non_centrality(), &outResult, Policy()))\n return kResultIsReady;\n\n if (inDist.degrees_of_freedom() < 2)\n outResult = boost::math::policies\n ::raise_overflow_error(function, 0, Policy());\n else if (inDist.degrees_of_freedom() == 2)\n // In this case, f(x) = exp(-lambda/2) * g(x), where g(x)\n // is the densitiy of a chi-squared distributed RV with 2\n // degrees of freedom, i.e., f(x) = exp(-lambda/2) / 2\n outResult = std::exp(-inDist.non_centrality()/2.) / 2.;\n else /* if (inDist.degrees_of_freedom() > 2) */\n outResult = 0;\n return kResultIsReady;\n }\n return Base::pdf(inDist, inX, outResult);\n }\n};\n\n/**\n * @brief Due to boost bug XXX, we need to check the corner cases for the pdf\n *\n * FIXME: No boost bug filed so far\n */\ntemplate \nstruct DomainCheck >\n : public PositiveDomainCheck<\n boost::math::non_central_f_distribution\n > {\n typedef boost::math::non_central_f_distribution Distribution;\n typedef PositiveDomainCheck Base;\n\n static ProbFnOverride pdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (inX == 0) {\n if(!boost::math::detail::check_df(function,\n inDist.degrees_of_freedom1(), &outResult, Policy())\n || !boost::math::detail::check_df(function,\n inDist.degrees_of_freedom2(), &outResult, Policy())\n || !boost::math::detail::check_non_centrality(function,\n inDist.non_centrality(), &outResult, Policy()))\n return kResultIsReady;\n\n if (inDist.degrees_of_freedom1() < 2)\n outResult = boost::math::policies\n ::raise_overflow_error(function, 0, Policy());\n else if (inDist.degrees_of_freedom1() == 2)\n // In this case, f(x) = exp(-lambda/2)\n outResult = std::exp(-inDist.non_centrality()/2.);\n else /* if (inDist.degrees_of_freedom1() > 2) */\n outResult = 0;\n return kResultIsReady;\n }\n return Base::pdf(inDist, inX, outResult);\n }\n};\n\n/**\n * @brief Override the domain check for Pareto: quantile\n *\n * For the Pareto distribution, boost sometimes returns max_value instead\n * of infinity. We override that.\n */\ntemplate \nstruct DomainCheck >\n : public PositiveDomainCheck<\n boost::math::pareto_distribution\n > {\n typedef boost::math::pareto_distribution Distribution;\n typedef PositiveDomainCheck Base;\n\n template \n static ProbFnOverride cdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::cdf(...)\";\n\n if (inX <= inDist.scale()) {\n if (boost::math::detail::check_pareto(function, inDist.scale(),\n inDist.shape(), &outResult, Policy()))\n outResult = 0;\n return kResultIsReady;\n }\n return Base::template cdf(inDist, inX, outResult);\n }\n\n static ProbFnOverride pdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::pdf(...)\";\n\n if (inX < inDist.scale()) {\n if (boost::math::detail::check_pareto(function, inDist.scale(),\n inDist.shape(), &outResult, Policy()))\n outResult = 0;\n return kResultIsReady;\n }\n return Base::pdf(inDist, inX, outResult);\n }\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (!boost::math::detail::check_pareto(function, inDist.scale(),\n inDist.shape(), &outResult, Policy()))\n return kResultIsReady;\n else if (inP == 1) {\n outResult = boost::math::policies::raise_overflow_error(\n function, 0, Policy());\n return kResultIsReady;\n }\n return Base::template quantile(inDist, inP, outResult);\n }\n};\n\n/**\n * @brief Due to boost bug 6937, we need to override the domain check for\n * quantile\n *\n * https://svn.boost.org/trac/boost/ticket/6937\n */\ntemplate \nstruct DomainCheck >\n : public NonNegativeIntegerDomainCheck<\n boost::math::poisson_distribution\n > {\n typedef boost::math::poisson_distribution Distribution;\n typedef NonNegativeIntegerDomainCheck Base;\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (!boost::math::poisson_detail::check_dist(function,\n inDist.mean(), &outResult, Policy()))\n return kResultIsReady;\n else if (inP == 1) {\n outResult = boost::math::policies::raise_overflow_error(\n function, 0, Policy());\n return kResultIsReady;\n }\n\n return Base::template quantile(inDist, inP, outResult);\n }\n};\n\n/**\n * @brief Due to boost bug XXX, we need to override the domain check for\n * quantile\n *\n * FIXME: No boost bug filed so far\n * Boost does not catch the case where sigma is NaN.\n */\ntemplate \nstruct DomainCheck >\n : public PositiveDomainCheck<\n boost::math::rayleigh_distribution\n > {\n typedef boost::math::rayleigh_distribution Distribution;\n typedef PositiveDomainCheck Base;\n\n static bool check_sigma_finite(const char* function, RealType sigma,\n RealType* result, const Policy& pol) {\n\n if (!boost::math::isfinite(sigma)) {\n *result = boost::math::policies::raise_domain_error(\n function,\n \"The scale parameter \\\"sigma\\\" must be finite, but was: %1%.\",\n sigma, pol);\n return false;\n }\n return true;\n }\n\n template \n static ProbFnOverride cdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::cdf(...)\";\n\n if (!check_sigma_finite(function, inDist.sigma(), &outResult, Policy()))\n return kResultIsReady;\n\n return Base::template cdf(inDist, inX, outResult);\n }\n\n static ProbFnOverride pdf(const Distribution& inDist,\n const RealType& inX, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::pdf(...)\";\n\n if (!check_sigma_finite(function, inDist.sigma(), &outResult, Policy()))\n return kResultIsReady;\n\n return Base::pdf(inDist, inX, outResult);\n }\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n\n if (!check_sigma_finite(function, inDist.sigma(), &outResult, Policy()))\n return kResultIsReady;\n\n return Base::template quantile(inDist, inP, outResult);\n }\n};\n\n/**\n * @brief Due to boost bugs 6938 and 6939, we need to override the domain checks\n *\n * https://svn.boost.org/trac/boost/ticket/6938\n * https://svn.boost.org/trac/boost/ticket/6939\n */\ntemplate \nstruct DomainCheck >\n : public PositiveDomainCheck<\n boost::math::weibull_distribution\n > {\n typedef boost::math::weibull_distribution Distribution;\n typedef PositiveDomainCheck Base;\n\n // BEGIN Copied from boost/math/distributions/weibull.hpp (v1.49), but replaced\n // \"<\" check by \"<=\".\n static bool check_weibull_shape(\n const char* function,\n RealType shape,\n RealType* result, const Policy& pol) {\n\n if((shape <= 0) || !(boost::math::isfinite)(shape)) {\n *result = boost::math::policies::raise_domain_error(\n function,\n \"Shape parameter is %1%, but must be > 0 !\", shape, pol);\n return false;\n }\n return true;\n }\n // END Copied from boost/math/distributions/weibull.hpp (v1.49)\n\n template \n static ProbFnOverride cdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::cdf(...)\";\n RealType shape = inDist.shape();\n if (!check_weibull_shape(function, shape, &outResult, Policy()))\n return kResultIsReady;\n\n return Base::template cdf(inDist, inX, outResult);\n }\n\n static ProbFnOverride pdf(const Distribution& inDist, const RealType& inX,\n RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::pdf(...)\";\n RealType shape = inDist.shape();\n if (!check_weibull_shape(function, shape, &outResult, Policy()))\n return kResultIsReady;\n\n if (inX == 0) {\n if (shape == 1)\n outResult = 1;\n else if (shape < 1)\n outResult = boost::math::policies::raise_overflow_error(\n function, 0, Policy());\n else\n return kLetBoostCalculate;\n\n return kResultIsReady;\n }\n return Base::pdf(inDist, inX, outResult);\n }\n\n template \n static ProbFnOverride quantile(const Distribution& inDist,\n const RealType& inP, RealType& outResult) {\n\n static const char* function = \"madlib::modules::prob::::\"\n \"DomainCheck >::quantile(...)\";\n RealType shape = inDist.shape();\n if (!check_weibull_shape(function, shape, &outResult, Policy()))\n return kResultIsReady;\n\n return Base::template quantile(inDist, inP, outResult);\n }\n};\n\n\n\n#define DOMAIN_CHECK_OVERRIDE(dist, check) \\\n template \\\n struct DomainCheck > \\\n : public check > { };\n\nDOMAIN_CHECK_OVERRIDE(beta, ZeroOneDomainCheck)\nDOMAIN_CHECK_OVERRIDE(chi_squared, PositiveDomainCheck)\nDOMAIN_CHECK_OVERRIDE(laplace, RealDomainCheck)\nDOMAIN_CHECK_OVERRIDE(non_central_t, RealDomainCheck)\nDOMAIN_CHECK_OVERRIDE(triangular, RealDomainCheck)\nDOMAIN_CHECK_OVERRIDE(uniform, RealDomainCheck)\n// The following lines are currently commented out. Each of these is a boost\n// deficiency unfortunately. See above.\n// DOMAIN_CHECK_OVERRIDE(exponential, PositiveDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(extreme_value, RealDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(fisher_f, PositiveDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(gamma, PositiveDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(geometric, NonNegativeIntegerDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(lognormal, PositiveDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(hypergeometric, NonNegativeIntegerDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(inverse_gamma, PositiveDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(negative_binomial, NonNegativeIntegerDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(non_central_beta, ZeroOneDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(non_central_chi_squared, PositiveDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(non_central_f, PositiveDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(pareto, PositiveDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(poisson, NonNegativeIntegerDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(rayleigh, PositiveDomainCheck)\n// DOMAIN_CHECK_OVERRIDE(weibull, PositiveDomainCheck)\n\n#undef DOMAIN_CHECK_OVERRIDE\n\n} // anonymous namespace\n\n#define DEFINE_BOOST_WRAPPER(_dist, _what, _domain_check_what) \\\n template \\\n inline \\\n RealType \\\n _what(const boost::math::_dist ## _distribution& dist, \\\n const RealType& x) { \\\n \\\n typedef boost::math::_dist ## _distribution Dist; \\\n RealType result; \\\n switch (DomainCheck::_domain_check_what(dist, x, result)) { \\\n case kResultIsReady: return result; \\\n case kLetBoostCalculate: return boost::math::_what(dist, x); \\\n case kLetBoostCalculateUsingValue: \\\n return boost::math::_what(dist, result); \\\n default: throw std::logic_error(\"Unexpected case detected in \" \\\n \"domain-check override for a boost probability function.\"); \\\n } \\\n }\n\n#define DEFINE_BOOST_COMPLEMENT_WRAPPER(_dist, _what) \\\n template \\\n inline \\\n RealType \\\n _what(const boost::math::complemented2_type< \\\n boost::math::_dist ## _distribution, \\\n RealType \\\n >& c) { \\\n typedef boost::math::_dist ## _distribution Dist; \\\n typedef boost::math::complemented2_type Complement; \\\n RealType result; \\\n switch (DomainCheck::template _what(c.dist, c.param, result)) { \\\n case kResultIsReady: return result; \\\n case kLetBoostCalculate: return boost::math::_what(c); \\\n case kLetBoostCalculateUsingValue: \\\n return boost::math::_what(Complement(c.dist, result)); \\\n default: throw std::logic_error(\"Unexpected case detected in \" \\\n \"domain-check override for a boost probability function.\"); \\\n } \\\n }\n\n#define DEFINE_BOOST_PROBABILITY_DISTR(_dist) \\\n typedef boost::math::_dist ## _distribution< \\\n double, boost_mathkit_policy> _dist; \\\n \\\n DEFINE_BOOST_WRAPPER(_dist, cdf, template cdf) \\\n DEFINE_BOOST_COMPLEMENT_WRAPPER(_dist, cdf) \\\n DEFINE_BOOST_WRAPPER(_dist, pdf, pdf) \\\n DEFINE_BOOST_WRAPPER(_dist, quantile, template quantile) \\\n DEFINE_BOOST_COMPLEMENT_WRAPPER(_dist, quantile)\n\n\n#define MADLIB_ITEM(_dist) \\\n DEFINE_BOOST_PROBABILITY_DISTR(_dist)\n\n// Note that boost also uses the pdf() if actually a probability mass function\n// is meant\nLIST_CONTINUOUS_PROB_DISTR\nLIST_DISCRETE_PROB_DISTR\n\n#undef MADLIB_ITEM\n#undef DEFINE_PROBABILITY_DISTR\n#undef DEFINE_BOOST_WRAPPER\n#undef LIST_CONTINUOUS_PROB_DISTR\n\n} // namespace prob\n\n} // namespace modules\n\n} // namespace regress\n\n#endif // defined(MADLIB_MODULES_PROB_BOOST_HPP)\n", "meta": {"hexsha": "cd70fd518f02afab8328dc859b04df2123cfc221", "size": 50520, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/modules/prob/boost.hpp", "max_stars_repo_name": "fmcquillan99/apache-madlib", "max_stars_repo_head_hexsha": "e2dea62d1eadc7f662f2d926c71f42332f414ca0", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2018-09-18T07:44:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-14T19:45:18.000Z", "max_issues_repo_path": "src/modules/prob/boost.hpp", "max_issues_repo_name": "fmcquillan99/apache-madlib", "max_issues_repo_head_hexsha": "e2dea62d1eadc7f662f2d926c71f42332f414ca0", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-09-06T05:50:17.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-06T05:50:17.000Z", "max_forks_repo_path": "src/modules/prob/boost.hpp", "max_forks_repo_name": "fmcquillan99/apache-madlib", "max_forks_repo_head_hexsha": "e2dea62d1eadc7f662f2d926c71f42332f414ca0", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-09-03T20:50:13.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-03T20:50:13.000Z", "avg_line_length": 36.3191948239, "max_line_length": 195, "alphanum_fraction": 0.6403602534, "num_tokens": 12077, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6548947290421276, "lm_q2_score": 0.5312093733737563, "lm_q1q2_score": 0.34788621864024455}} {"text": "// Copyright 2018 The Simons Foundation, Inc. - All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n#ifndef NETKET_ADADELTA_HPP\n#define NETKET_ADADELTA_HPP\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"abstract_stepper.hpp\"\n\nnamespace netket {\n\nclass AdaDelta : public AbstractStepper {\n int npar_;\n\n double rho_;\n double epscut_;\n\n Eigen::VectorXd Eg2_;\n Eigen::VectorXd Edx2_;\n\n int mynode_;\n\n const std::complex I_;\n\n public:\n // Json constructor\n explicit AdaDelta(const json &pars)\n : rho_(FieldOrDefaultVal(pars[\"Learning\"], \"Rho\", 0.95)),\n epscut_(FieldOrDefaultVal(pars[\"Learning\"], \"Epscut\", 1.0e-7)),\n I_(0, 1) {\n npar_ = -1;\n\n PrintParameters();\n }\n\n void PrintParameters() {\n MPI_Comm_rank(MPI_COMM_WORLD, &mynode_);\n if (mynode_ == 0) {\n std::cout << \"# Adadelta stepper initialized with these parameters : \"\n << std::endl;\n std::cout << \"# Rho = \" << rho_ << std::endl;\n std::cout << \"# Epscut = \" << epscut_ << std::endl;\n }\n }\n\n void Init(const Eigen::VectorXd &pars) override {\n npar_ = pars.size();\n Eg2_.setZero(npar_);\n Edx2_.setZero(npar_);\n\n }\n\n void Init(const Eigen::VectorXcd &pars) override {\n npar_ = 2 * pars.size();\n Eg2_.setZero(npar_);\n Edx2_.setZero(npar_);\n\n }\n\n void Update(const Eigen::VectorXd &grad, Eigen::VectorXd &pars) override {\n assert(npar_ > 0);\n\n Eg2_=rho_*Eg2_+(1.-rho_)*grad.cwiseAbs2();\n\n Eigen::VectorXd Dx(npar_);\n\n for(int i=0;i\r\n#include \"mitkNumericTypes.h\"\r\n\r\n// for Windows\r\n#ifndef M_PI\r\n#define M_PI 3.14159265358979323846\r\n#endif\r\n\r\n// Namespace ::SH\r\n#include \r\n#include \r\n#include \r\n\r\n\r\n// Namespace ::Gradients\r\n#include \"itkVectorContainer.h\"\r\n#include \"vnl/vnl_vector.h\"\r\n\r\n//------------------------- SH-function ------------------------------------\r\n\r\ndouble mitk::sh::factorial(int number) {\r\n if(number <= 1) return 1;\r\n double result = 1.0;\r\n for(int i=1; i<=number; i++)\r\n result *= i;\r\n return result;\r\n}\r\n\r\nvoid mitk::sh::Cart2Sph(double x, double y, double z, double *cart)\r\n{\r\n double phi, th, rad;\r\n rad = sqrt(x*x+y*y+z*z);\r\n if( rad < mitk::eps )\r\n {\r\n th = M_PI/2;\r\n phi = M_PI/2;\r\n }\r\n else\r\n {\r\n th = acos(z/rad);\r\n phi = atan2(y, x);\r\n }\r\n cart[0] = phi;\r\n cart[1] = th;\r\n cart[2] = rad;\r\n}\r\n\r\ndouble mitk::sh::legendre0(int l)\r\n{\r\n if( l%2 != 0 )\r\n {\r\n return 0;\r\n }\r\n else\r\n {\r\n double prod1 = 1.0;\r\n for(int i=1;i mitk::gradients::GetAllUniqueDirections(const BValueMap & refBValueMap, GradientDirectionContainerType *refGradientsContainer )\r\n{\r\n\r\n IndiciesVector directioncontainer;\r\n auto mapIterator = refBValueMap.begin();\r\n\r\n if(refBValueMap.find(0) != refBValueMap.end() && refBValueMap.size() > 1)\r\n mapIterator++; //skip bzero Values\r\n\r\n for( ; mapIterator != refBValueMap.end(); mapIterator++){\r\n\r\n IndiciesVector currentShell = mapIterator->second;\r\n\r\n while(currentShell.size()>0)\r\n {\r\n unsigned int wntIndex = currentShell.back();\r\n currentShell.pop_back();\r\n\r\n auto containerIt = directioncontainer.begin();\r\n bool directionExist = false;\r\n while(containerIt != directioncontainer.end())\r\n {\r\n if (fabs(dot(refGradientsContainer->ElementAt(*containerIt), refGradientsContainer->ElementAt(wntIndex))) > 0.9998)\r\n {\r\n directionExist = true;\r\n break;\r\n }\r\n containerIt++;\r\n }\r\n if(!directionExist)\r\n {\r\n directioncontainer.push_back(wntIndex);\r\n }\r\n }\r\n }\r\n\r\n return directioncontainer;\r\n}\r\n\r\n\r\nbool mitk::gradients::CheckForDifferingShellDirections(const BValueMap & refBValueMap, GradientDirectionContainerType::ConstPointer refGradientsContainer)\r\n{\r\n auto mapIterator = refBValueMap.begin();\r\n\r\n if(refBValueMap.find(0) != refBValueMap.end() && refBValueMap.size() > 1)\r\n mapIterator++; //skip bzero Values\r\n\r\n for( ; mapIterator != refBValueMap.end(); mapIterator++){\r\n\r\n auto mapIterator_2 = refBValueMap.begin();\r\n if(refBValueMap.find(0) != refBValueMap.end() && refBValueMap.size() > 1)\r\n mapIterator_2++; //skip bzero Values\r\n\r\n for( ; mapIterator_2 != refBValueMap.end(); mapIterator_2++){\r\n\r\n if(mapIterator_2 == mapIterator) continue;\r\n\r\n IndiciesVector currentShell = mapIterator->second;\r\n IndiciesVector testShell = mapIterator_2->second;\r\n for (unsigned int i = 0; i< currentShell.size(); i++)\r\n if (fabs(dot(refGradientsContainer->ElementAt(currentShell[i]), refGradientsContainer->ElementAt(testShell[i]))) <= 0.9998) { return true; }\r\n\r\n }\r\n }\r\n return false;\r\n}\r\n\r\n\r\ntemplate\r\ndouble mitk::gradients::dot (vnl_vector_fixed< type ,3> const& v1, vnl_vector_fixed< type ,3 > const& v2 )\r\n{\r\n double result = (v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]) / (v1.two_norm() * v2.two_norm());\r\n return result ;\r\n}\r\n\r\nvnl_matrix mitk::gradients::ComputeSphericalFromCartesian(const IndiciesVector & refShell, const GradientDirectionContainerType * refGradientsContainer)\r\n{\r\n\r\n vnl_matrix Q(3, refShell.size());\r\n Q.fill(0.0);\r\n\r\n for(unsigned int i = 0; i < refShell.size(); i++)\r\n {\r\n GradientDirectionType dir = refGradientsContainer->ElementAt(refShell[i]);\r\n double x = dir.normalize().get(0);\r\n double y = dir.normalize().get(1);\r\n double z = dir.normalize().get(2);\r\n double cart[3];\r\n mitk::sh::Cart2Sph(x,y,z,cart);\r\n Q(0,i) = cart[0];\r\n Q(1,i) = cart[1];\r\n Q(2,i) = cart[2];\r\n }\r\n return Q;\r\n}\r\n\r\nvnl_matrix mitk::gradients::ComputeSphericalHarmonicsBasis(const vnl_matrix & QBallReference, const unsigned int & LOrder)\r\n{\r\n vnl_matrix SHBasisOutput(QBallReference.cols(), (LOrder+1)*(LOrder+2)*0.5);\r\n SHBasisOutput.fill(0.0);\r\n for(int i=0; i< (int)SHBasisOutput.rows(); i++)\r\n for(int k = 0; k <= (int)LOrder; k += 2)\r\n for(int m =- k; m <= k; m++)\r\n {\r\n int j = ( k * k + k + 2 ) / 2.0 + m - 1;\r\n double phi = QBallReference(0,i);\r\n double th = QBallReference(1,i);\r\n double val = mitk::sh::Yj(m,k,th,phi);\r\n SHBasisOutput(i,j) = val;\r\n }\r\n return SHBasisOutput;\r\n}\r\n\r\nmitk::gradients::GradientDirectionContainerType::Pointer mitk::gradients::CreateNormalizedUniqueGradientDirectionContainer(const mitk::gradients::BValueMap & bValueMap,\r\n const GradientDirectionContainerType *origninalGradentcontainer)\r\n{\r\n mitk::gradients::GradientDirectionContainerType::Pointer directioncontainer = mitk::gradients::GradientDirectionContainerType::New();\r\n auto mapIterator = bValueMap.begin();\r\n\r\n if(bValueMap.find(0) != bValueMap.end() && bValueMap.size() > 1){\r\n mapIterator++; //skip bzero Values\r\n vnl_vector_fixed vec;\r\n vec.fill(0.0);\r\n directioncontainer->push_back(vec);\r\n }\r\n\r\n for( ; mapIterator != bValueMap.end(); mapIterator++){\r\n\r\n IndiciesVector currentShell = mapIterator->second;\r\n\r\n while(currentShell.size()>0)\r\n {\r\n unsigned int wntIndex = currentShell.back();\r\n currentShell.pop_back();\r\n\r\n mitk::gradients::GradientDirectionContainerType::Iterator containerIt = directioncontainer->Begin();\r\n bool directionExist = false;\r\n while(containerIt != directioncontainer->End())\r\n {\r\n if (fabs(dot(containerIt.Value(), origninalGradentcontainer->ElementAt(wntIndex))) > 0.9998)\r\n {\r\n directionExist = true;\r\n break;\r\n }\r\n containerIt++;\r\n }\r\n if(!directionExist)\r\n {\r\n GradientDirectionType dir(origninalGradentcontainer->ElementAt(wntIndex));\r\n directioncontainer->push_back(dir.normalize());\r\n }\r\n }\r\n }\r\n\r\n return directioncontainer;\r\n}\r\n", "meta": {"hexsha": "5d880023721c72033cc2ae3ed709ba8261e7251d", "size": 7524, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Modules/DiffusionImaging/DiffusionCore/src/mitkDiffusionFunctionCollection.cpp", "max_stars_repo_name": "liu3xing3long/MITK-2016.11", "max_stars_repo_head_hexsha": "385c506f9792414f40337e106e13d5fd61aa3ccc", "max_stars_repo_licenses": ["Apache-2.0", "BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Modules/DiffusionImaging/DiffusionCore/src/mitkDiffusionFunctionCollection.cpp", "max_issues_repo_name": "liu3xing3long/MITK-2016.11", "max_issues_repo_head_hexsha": "385c506f9792414f40337e106e13d5fd61aa3ccc", "max_issues_repo_licenses": ["Apache-2.0", "BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Modules/DiffusionImaging/DiffusionCore/src/mitkDiffusionFunctionCollection.cpp", "max_forks_repo_name": "liu3xing3long/MITK-2016.11", "max_forks_repo_head_hexsha": "385c506f9792414f40337e106e13d5fd61aa3ccc", "max_forks_repo_licenses": ["Apache-2.0", "BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.6220472441, "max_line_length": 169, "alphanum_fraction": 0.6197501329, "num_tokens": 2019, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6548947155710234, "lm_q2_score": 0.5312093733737563, "lm_q1q2_score": 0.3478862114842677}} {"text": "#include \"utils.h\"\n\n#include \n#include \n#include \n\n\n#include \n#include \n\n\nauto random_engine = std::mt19937(std::time(0));\n\nvoid train_with_features(std::string data_file_path,\n std::string features_file_path,\n std::string noise_file_path,\n int n_steps, double eta_0, double iter_power,\n size_t l_dimensions, size_t k_dimensions,\n std::string output_file_path,\n std::string objective_output_file_path) {\n // Data loading\n std::fstream data_file_input;\n data_file_input.open(data_file_path, std::ios::in);\n std::string line;\n std::vector tokens;\n getline(data_file_input, line);\n boost::split(tokens, line, boost::is_any_of(\",\"));\n size_t data_size = stoul(tokens[0]);\n size_t n_samples = stoul(tokens[1]);\n\n std::vector start_indexes(n_samples);\n std::vector permutation(n_samples);\n std::vector data(data_size + n_samples);\n long n_data = 0;\n long n_noise = 0;\n for (size_t i = 0, data_index = 0; i < n_samples; ++i) {\n getline(data_file_input, line);\n boost::split(tokens, line, boost::is_any_of(\",\"));\n start_indexes[i] = data_index;\n permutation[i] = i;\n for (size_t j = 0; j < tokens.size(); ++j) {\n data[data_index + j] = stoi(tokens[j]);\n }\n if (data[data_index] == 0) {\n ++n_noise;\n } else {\n ++n_data;\n }\n data[data_index + tokens.size()] = -1;\n data_index += tokens.size() + 1;\n }\n\n size_t n_items;\n size_t m_features;\n std::vector features;\n auto index_features = [&m_features](size_t i, size_t j) -> size_t {\n return (i * m_features) + j;\n };\n masterthesis::readFeatureFile(\n features_file_path, &n_items, &m_features, &features);\n\n std::fstream noise_file_input;\n noise_file_input.open(noise_file_path, std::ios::in);\n getline(noise_file_input, line);\n boost::split(tokens, line, boost::is_any_of(\",\"));\n std::vector a_weights(m_features);\n for (size_t i = 0; i < m_features; ++i) {\n a_weights[i] = stod(tokens[i]);\n }\n getline(noise_file_input, line);\n boost::split(tokens, line, boost::is_any_of(\",\"));\n std::vector noise_utilities(n_items);\n for (size_t i = 0; i < n_items; ++i) {\n noise_utilities[i] = stod(tokens[i]);\n }\n\n\n // Calculate constant quantities.\n double nu = n_noise / n_data;\n double log_nu = log(nu);\n double logz_noise = 0;\n for (size_t i = 0; i < n_items; ++i) {\n logz_noise += masterthesis::log1exp(noise_utilities[i]);\n }\n\n // Initialize parameters.\n std::uniform_real_distribution udouble_dist(0, 1e-3);\n std::vector b_weights(m_features * l_dimensions);\n std::vector c_weights(m_features * k_dimensions);\n double n_logz = 0;\n\n auto index_b_weights = [&l_dimensions](size_t i, size_t j) -> size_t {\n return (i * l_dimensions) + j;\n };\n\n auto index_c_weights = [&k_dimensions](size_t i, size_t j) -> size_t {\n return (i * k_dimensions) + j;\n };\n\n for (size_t i = 0; i < m_features; ++i) {\n for (size_t j = 0; j < l_dimensions; ++j) {\n b_weights[index_b_weights(i, j)] = udouble_dist(random_engine);\n }\n for (size_t j = 0; j < k_dimensions; ++j) {\n c_weights[index_c_weights(i, j)] = udouble_dist(random_engine);\n }\n }\n for (size_t i = 0; i < n_items; ++i) {\n double item_util = 0;\n for (size_t j = 0; j < m_features; ++j) {\n item_util += a_weights[j] * features[index_features(i, j)];\n }\n n_logz -= masterthesis::log1exp(item_util);\n }\n std::cout << logz_noise << \" \" << n_logz << std::endl;\n\n std::vector a_gradient(m_features);\n std::vector objectives(n_steps);\n for (size_t iter = 0; iter < n_steps; ++iter) {\n double objective = 0;\n for (size_t sub_iter = 0; sub_iter < n_samples; ++sub_iter) {\n size_t start_idx = start_indexes[sub_iter];\n size_t end_idx;\n if (sub_iter == n_samples - 1) {\n end_idx = data_size + n_samples - 1;\n } else {\n end_idx = start_indexes[sub_iter + 1] - 1;\n }\n int label = data[start_idx];\n double p_model = n_logz;\n double p_noise = -logz_noise;\n for (size_t j = 0; j < m_features; ++j) {\n for (size_t i = start_idx + 1; i < end_idx; ++i) {\n p_model += features[index_features(data[i], j)] *\n a_weights[j];\n }\n }\n for (size_t i = start_idx + 1; i < end_idx; ++i) {\n p_noise += noise_utilities[data[i]];\n }\n for (size_t j = 0; j < l_dimensions; ++j) {\n double max_b_weight = -1;\n for (size_t i = start_idx + 1; i < end_idx; ++i) {\n double weight = 0;\n for (size_t k = 0; k < m_features; ++k) {\n weight += features[index_features(data[i], k)] *\n b_weights[index_b_weights(k, j)];\n }\n if (weight > max_b_weight) {\n max_b_weight = weight;\n }\n p_model -= weight;\n }\n if (max_b_weight >= 0) {\n p_model += max_b_weight;\n }\n }\n for (size_t j = 0; j < k_dimensions; ++j) {\n double max_c_weight = -1;\n for (size_t i = start_idx + 1; i < end_idx; ++i) {\n double weight = 0;\n for (size_t k = 0; k < m_features; ++k) {\n weight += features[index_features(data[i], k)] *\n c_weights[index_c_weights(k, j)];\n }\n if (weight > max_c_weight) {\n max_c_weight = weight;\n }\n p_model += weight;\n }\n if (max_c_weight >= 0) {\n p_model -= max_c_weight;\n }\n }\n if (label == 1) {\n objective -= masterthesis::log1exp(log_nu + p_noise - p_model);\n } else {\n objective -= masterthesis::log1exp(p_model - log_nu - p_noise);\n }\n }\n std::cout << objective << std::endl;\n objectives[iter] = objective;\n shuffle(begin(permutation), end(permutation), random_engine);\n for (size_t sub_iter = 0; sub_iter < n_samples; ++sub_iter) {\n size_t start_idx = start_indexes[permutation[sub_iter]];\n size_t end_idx;\n if (permutation[sub_iter] == n_samples - 1) {\n end_idx = data_size + n_samples - 1;\n } else {\n end_idx = start_indexes[permutation[sub_iter] + 1] - 1;\n }\n bool isEmpty = (start_idx == end_idx - 1);\n int label = data[start_idx];\n double p_model = n_logz;\n double p_noise = -logz_noise;\n for (size_t j = 0; j < m_features; ++j) {\n a_gradient[j] = 0;\n for (size_t i = start_idx + 1; i < end_idx; ++i) {\n a_gradient[j] += features[index_features(data[i], j)];\n p_model += features[index_features(data[i], j)] *\n a_weights[j];\n }\n }\n for (size_t i = start_idx + 1; i < end_idx; ++i) {\n p_noise += noise_utilities[data[i]];\n }\n\n\n std::vector max_b_weights(l_dimensions);\n std::vector max_weight_b_indexes(l_dimensions);\n std::vector max_c_weights(k_dimensions);\n std::vector max_weight_c_indexes(k_dimensions);\n if (!isEmpty) {\n for (size_t j = 0; j < l_dimensions; ++j) {\n max_b_weights[j] = -1;\n max_weight_b_indexes[j] = -1;\n for (size_t i = start_idx + 1; i < end_idx; ++i) {\n double weight = 0;\n for (size_t k = 0; k < m_features; ++k) {\n weight += features[index_features(data[i], k)] *\n b_weights[index_b_weights(k, j)];\n }\n if (weight > max_b_weights[j]) {\n max_b_weights[j] = weight;\n max_weight_b_indexes[j] = data[i];\n }\n p_model -= weight;\n }\n p_model += max_b_weights[j];\n }\n\n for (size_t j = 0; j < k_dimensions; ++j) {\n max_c_weights[j] = -1;\n max_weight_c_indexes[j] = -1;\n for (size_t i = start_idx + 1; i < end_idx; ++i) {\n double weight = 0;\n for (size_t k = 0; k < m_features; ++k) {\n weight += features[index_features(data[i], k)] *\n c_weights[index_c_weights(k, j)];\n }\n if (weight > max_c_weights[j]) {\n max_c_weights[j] = weight;\n max_weight_c_indexes[j] = data[i];\n }\n p_model += weight;\n }\n p_model -= max_c_weights[j];\n }\n }\n\n double learning_rate = eta_0 *\n pow((iter * n_samples) + sub_iter + 1, -iter_power);\n double factor = learning_rate *\n (label - masterthesis::expit(p_model - p_noise - log_nu));\n if (!isEmpty) {\n for (size_t i = 0; i < m_features; ++i) {\n a_weights[i] += factor * a_gradient[i];\n for (size_t j = 0; j < l_dimensions; ++j) {\n b_weights[index_b_weights(i, j)] += factor *\n (features[index_features(\n max_weight_b_indexes[j],\n i)] -\n a_gradient[i]);\n if (b_weights[index_b_weights(i, j)] <= 0) {\n b_weights[index_b_weights(i, j)] = udouble_dist(random_engine);\n }\n }\n for (size_t j = 0; j < k_dimensions; ++j) {\n c_weights[index_c_weights(i, j)] += factor *\n (a_gradient[i] -\n features[index_features(\n max_weight_c_indexes[j],\n i)]);\n if (c_weights[index_c_weights(i, j)] <= 0) {\n c_weights[index_c_weights(i, j)] = udouble_dist(random_engine);\n }\n }\n }\n }\n n_logz += factor;\n }\n }\n\n std::fstream output_file(output_file_path, std::ios::out);\n\n output_file << n_logz << std::endl;\n for (size_t i = 0; i < m_features - 1; ++i) {\n output_file << a_weights[i] << \",\";\n }\n output_file << a_weights[m_features - 1] << std::endl;\n\n for (size_t i = 0; i < m_features; ++i) {\n if (l_dimensions > 0) {\n for (size_t j = 0; j < l_dimensions - 1; ++j) {\n output_file << b_weights[index_b_weights(i, j)] << \",\";\n }\n output_file << b_weights[index_b_weights(i, l_dimensions - 1)] << std::endl;\n }\n }\n\n for (size_t i = 0; i < m_features; ++i) {\n if (k_dimensions > 0) {\n for (size_t j = 0; j < k_dimensions - 1; ++j) {\n output_file << c_weights[index_c_weights(i, j)] << \",\";\n }\n output_file << c_weights[index_c_weights(i, k_dimensions - 1)] << std::endl;\n }\n }\n\n output_file.close();\n\n std::fstream objective_output_file(\n objective_output_file_path, std::ios::out);\n\n for (size_t i = 0; i < n_steps; ++i) {\n objective_output_file << objectives[i] << std::endl;\n }\n\n objective_output_file.close();\n}\n\nint main(int argc, char* argv[]) {\n int fold_number = std::stoi(argv[1]);\n int l_dimensions = std::stoi(argv[2]);\n int k_dimensions = std::stoi(argv[3]);\n char* feature_set = argv[4];\n char* dataset_name = argv[5];\n int iterations = std::stoi(argv[6]);\n std::vector times(fold_number);\n for (int i = 1; i <= fold_number; ++i) {\n time_t start = time(0);\n train_with_features(\n (boost::format(\n \"/home/diegob/workspace/master-thesis-2015/data/path_set_%1%_nce_data_features_%2%_fold_%3%.csv\") %\n dataset_name % feature_set % i).str(),\n (boost::format(\n \"/home/diegob/workspace/master-thesis-2015/data/path_set_%1%_nce_features_%2%.csv\") %\n dataset_name % feature_set).str(),\n (boost::format(\n \"/home/diegob/workspace/master-thesis-2015/data/path_set_%1%_nce_noise_features_%2%_fold_%3%.csv\") %\n dataset_name % feature_set % i).str(),\n iterations, 0.00005, 0.1,\n static_cast(l_dimensions),\n static_cast(k_dimensions),\n (boost::format(\n \"/home/diegob/workspace/master-thesis-2015/data/models/path_set_%1%_nce_out_features_%2%_l_dim_%3%_k_dim_%4%_fold_%5%.csv\") %\n dataset_name % feature_set % l_dimensions % k_dimensions % i).str(),\n (boost::format(\n \"/home/diegob/workspace/master-thesis-2015/data/models/path_set_%1%_nce_objective_features_%2%_l_dim_%3%_k_dim_%4%_fold_%5%.csv\") %\n dataset_name % feature_set % l_dimensions % k_dimensions % i).str()\n );\n time_t end = time(0);\n double time = std::difftime(end, start);\n times[i-1] = time;\n std::cout << \"Fold finished.\" << std::endl;\n std::cout << \"Fold took: \" << times[i-1] << \"s\" << std::endl;\n }\n std::fstream times_output_file(\n (boost::format(\n \"/home/diegob/workspace/master-thesis-2015/data/models/path_set_%1%_nce_timing_features_%2%_l_dim_%3%_k_dim_%4%.csv\") %\n dataset_name % feature_set % l_dimensions % k_dimensions).str(),\n std::ios::out);\n\n for (size_t i = 0; i < fold_number; ++i) {\n times_output_file << times[i] << std::endl;\n }\n times_output_file.close();\n}\n", "meta": {"hexsha": "c640f0acbc9703e533f4f40921b30c5b1f3eee77", "size": 15310, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "cppsrc/train_general.cpp", "max_stars_repo_name": "dballesteros7/master-thesis-2015", "max_stars_repo_head_hexsha": "8c0bf9a6eef172fc8167a30780ae0666f8ea2d88", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cppsrc/train_general.cpp", "max_issues_repo_name": "dballesteros7/master-thesis-2015", "max_issues_repo_head_hexsha": "8c0bf9a6eef172fc8167a30780ae0666f8ea2d88", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cppsrc/train_general.cpp", "max_forks_repo_name": "dballesteros7/master-thesis-2015", "max_forks_repo_head_hexsha": "8c0bf9a6eef172fc8167a30780ae0666f8ea2d88", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.4905149051, "max_line_length": 155, "alphanum_fraction": 0.4830176355, "num_tokens": 3587, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6548947155710234, "lm_q2_score": 0.5312093733737563, "lm_q1q2_score": 0.3478862114842677}} {"text": "/*\n * lorenz_multi.cpp\n * Date: 2016-02-26\n * Author: Karsten Ahnert (karsten.ahnert@gmx.de)\n * Copyright: Karsten Ahnert\n *\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or\n * copy at http://www.boost.org/LICENSE_1_0.txt)\n */\n\n#include \"generate_data.hpp\"\n#include \"tree_types.hpp\"\n#include \"program_options.hpp\"\n#include \"serialize.hpp\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \n\nnamespace po = boost::program_options;\n\n\nint main( int argc , char** argv )\n{\n auto options = dynsys::get_options();\n auto positional_options = dynsys::get_positional_options();\n \n po::options_description cmdline_options;\n cmdline_options.add( options ).add( positional_options.second );\n \n po::variables_map vm;\n try\n {\n po::store( po::command_line_parser( argc , argv ).options( cmdline_options ).positional( positional_options.first ).run() , vm );\n po::notify( vm );\n }\n catch( std::exception& e )\n {\n std::cerr << \"Error \" << e.what() << \"\\n\\n\";\n std::cerr << cmdline_options << \"\\n\";\n return -1;\n }\n \n dynsys::rng_type rng;\n \n \n //[ create_lorenz_data\n auto training_data = dynsys::generate_data();\n \n std::array< std::pair< double , double > , dynsys::dim > xstat , ystat;\n for( size_t i=0 ; i;\n using fitness_type = std::vector< double >;\n \n fitness_type fitness ( population_size , 0.0 );\n population_type population ( population_size );\n //]\n \n \n //[ define_evolution\n using evolver_type = gpcxx::dynamic_pipeline< population_type , fitness_type , dynsys::rng_type >;\n evolver_type evolver( rng , number_elite );\n //]\n \n //[define_evaluator\n \n auto evaluator = []( auto const& individual , auto const& context ) {\n return dynsys::state_type {{\n individual[0].root()->eval( context ) ,\n individual[1].root()->eval( context ) ,\n individual[2].root()->eval( context ) }}; };\n \n auto distance = []( auto const& y , auto const& ytrain ) {\n const double weight_x = 1.0;\n const double weight_y = 1.0;\n const double weight_z = 1.0;\n dynsys::state_type diff {{ y[0] - ytrain[0] , y[1] - ytrain[1] , y[2] - ytrain[2] }};\n return weight_x * diff[0] * diff[0] + weight_y * diff[1] * diff[1] + weight_z * diff[2] * diff[2]; };\n //]\n \n //[define_genetic_operators\n auto tree_generator = gpcxx::make_ramp( rng , node_generator , min_tree_height , max_tree_height , 0.5 );\n auto fitness_f1 = gpcxx::make_multi_regression_fitness( evaluator , distance );\n auto fitness_f = [ fitness_f1 ]( auto const& individual , auto const& x , auto const& y ) {\n return fitness_f1.get_chi2( individual , x , y ); };\n evolver.add_operator(\n gpcxx::make_multi_mutation(\n rng , \n gpcxx::make_point_mutation( rng , tree_generator , max_tree_height , 20 ) ,\n gpcxx::make_tournament_selector( rng , tournament_size )\n ) , mutation_rate );\n evolver.add_operator(\n gpcxx::make_multi_crossover(\n rng ,\n gpcxx::make_one_point_crossover_strategy( rng , 10 ) ,\n gpcxx::make_tournament_selector( rng , tournament_size )\n ) , crossover_rate );\n evolver.add_operator(\n gpcxx::make_reproduce(\n gpcxx::make_tournament_selector( rng , tournament_size )\n ) , reproduction_rate );\n //]\n \n \n \n //[init_population\n std::ofstream fout { vm[ \"evolution\" ].as< std::string >() };\n for( size_t i=0 ; i() };\n fout2.precision( 14 );\n for( size_t j=0 ; j idx;\n gpcxx::sort_indices( fitness , idx );\n std::ofstream winner_out { vm[ \"winner\" ].as< std::string >() };\n winner_out << dynsys::serialize_winner( population[ idx[0] ] , xstat , ystat ) << \"\\n\";\n \n\n return 0;\n}", "meta": {"hexsha": "f7afff937755f699e77c198fdc07bcc48a6130b4", "size": 7118, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/dynamical_system/lorenz_multi.cpp", "max_stars_repo_name": "gchoinka/gpcxx", "max_stars_repo_head_hexsha": "143398d8a12cdc39735e6ef50c3f8a44a6e6360f", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 21.0, "max_stars_repo_stars_event_min_datetime": "2015-05-15T08:01:37.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-12T07:28:54.000Z", "max_issues_repo_path": "examples/dynamical_system/lorenz_multi.cpp", "max_issues_repo_name": "gchoinka/gpcxx", "max_issues_repo_head_hexsha": "143398d8a12cdc39735e6ef50c3f8a44a6e6360f", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2015-03-26T23:48:04.000Z", "max_issues_repo_issues_event_max_datetime": "2016-02-29T14:16:37.000Z", "max_forks_repo_path": "examples/dynamical_system/lorenz_multi.cpp", "max_forks_repo_name": "gchoinka/gpcxx", "max_forks_repo_head_hexsha": "143398d8a12cdc39735e6ef50c3f8a44a6e6360f", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 9.0, "max_forks_repo_forks_event_min_datetime": "2015-02-12T21:39:01.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-01T05:14:08.000Z", "avg_line_length": 34.2211538462, "max_line_length": 137, "alphanum_fraction": 0.5931441416, "num_tokens": 1910, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6548947155710233, "lm_q2_score": 0.5312093733737563, "lm_q1q2_score": 0.3478862114842676}} {"text": "// smooth_feedback: Control theory on Lie groups\n// https://github.com/pettni/smooth_feedback\n//\n// Licensed under the MIT License .\n//\n// Copyright (c) 2021 Petter Nilsson, John B. Mains\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\n#ifndef BENCHMARK__BENCH_TYPES_HPP_\n#define BENCHMARK__BENCH_TYPES_HPP_\n\n#include \n#include \n\n#include \n\n#include \n#include \n#include \n#include \n\n/**\n * @brief Create a random quadratic program of dimension m x n.\n * @param m number on inequalities\n * @param n number of variables\n * @param density approximate proportion of nonzeros in P and A\n * @param RNG random number generator\n */\ntemplate\nsmooth::feedback::QuadraticProgram<-1, -1> random_qp(int m, int n, double density, RNG & rng)\n{\n std::bernoulli_distribution bdist(density);\n std::uniform_real_distribution udist(-1, 1);\n\n Eigen::MatrixXd A =\n Eigen::MatrixXd::NullaryExpr(m, n, [&](int, int) { return bdist(rng) ? udist(rng) : 0.; });\n Eigen::MatrixXd Lrand =\n Eigen::MatrixXd::NullaryExpr(n, n, [&](int, int) { return bdist(rng) ? udist(rng) : 0.; });\n Eigen::MatrixXd L = Eigen::MatrixXd::Zero(n, n);\n L.template triangularView() = Lrand.template triangularView();\n for (int i = 0; i < n; ++i) { L(i, i) = std::max({L(i, i), -L(i, i), 0.05}); }\n\n Eigen::VectorXd v = Eigen::VectorXd::NullaryExpr(n, [&](int) { return udist(rng); });\n Eigen::VectorXd delta = Eigen::VectorXd::NullaryExpr(m, [&](int) { return udist(rng); });\n\n return smooth::feedback::QuadraticProgram<-1, -1>{\n .P = L * L.transpose(),\n .q = Eigen::VectorXd::NullaryExpr(n, [&](int) { return udist(rng); }),\n .A = A,\n .l = Eigen::VectorXd::Constant(m, -std::numeric_limits::infinity()),\n .u = A * v + delta,\n };\n}\n\n/**\n * @brief Create a random sparse quadratic program of dimension m x n.\n */\ninline smooth::feedback::QuadraticProgramSparse\nqp_dense_to_sparse(const smooth::feedback::QuadraticProgram<-1, -1, double> & qp)\n{\n smooth::feedback::QuadraticProgramSparse qps;\n\n qps.P = qp.P.sparseView();\n qps.P.prune(1e-6);\n qps.P.makeCompressed();\n qps.q = qp.q;\n qps.A = qp.A.sparseView();\n qps.A.prune(1e-6);\n qps.A.makeCompressed();\n qps.l = qp.l;\n qps.u = qp.u;\n\n return qps;\n}\n\nstruct BenchResult\n{\n smooth::feedback::QPSolutionStatus status;\n std::chrono::high_resolution_clock::duration dt;\n uint64_t iter;\n Eigen::VectorXd solution;\n double objective;\n};\n\nstruct BatchResult\n{\n std::vector results{};\n\n std::size_t num_optimal{0};\n\n double total_duration_success{0};\n double total_duration_fail{0};\n\n double avg_duration_success{0};\n double avg_duration_fail{0};\n};\n\ntemplate\nBatchResult solve_batch(const R & qps, const smooth::feedback::QPSolverParams & prm)\n{\n auto work_range =\n std::views::transform(qps, [&prm](const auto & qp) { return SolverWrapper(qp, prm); });\n\n BatchResult ret{};\n\n for (const auto & work : work_range) { ret.results.push_back(work()); }\n\n // calculate accuracies\n for (const auto & result : ret.results) {\n if (result.status == smooth::feedback::QPSolutionStatus::Optimal) {\n ++ret.num_optimal;\n ret.total_duration_success += std::chrono::duration(result.dt).count();\n } else {\n ret.total_duration_fail += std::chrono::duration(result.dt).count();\n }\n }\n\n std::size_t num_fail = ret.results.size() - ret.num_optimal;\n\n ret.avg_duration_success =\n ret.num_optimal > 0 ? ret.total_duration_success / ret.num_optimal : -1;\n ret.avg_duration_fail = num_fail > 0 ? ret.total_duration_fail / num_fail : -1;\n\n return ret;\n}\n\n#endif // BENCHMARK__BENCH_TYPES_HPP_\n", "meta": {"hexsha": "c45da2f65796fc13aac4dfea29ccdb1163da99b1", "size": 4880, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "benchmarks/bench_types.hpp", "max_stars_repo_name": "tgurriet/smooth_feedback", "max_stars_repo_head_hexsha": "1f926cb4269741ddc09ba048af5bea5e0390a053", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "benchmarks/bench_types.hpp", "max_issues_repo_name": "tgurriet/smooth_feedback", "max_issues_repo_head_hexsha": "1f926cb4269741ddc09ba048af5bea5e0390a053", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "benchmarks/bench_types.hpp", "max_forks_repo_name": "tgurriet/smooth_feedback", "max_forks_repo_head_hexsha": "1f926cb4269741ddc09ba048af5bea5e0390a053", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.6551724138, "max_line_length": 95, "alphanum_fraction": 0.6989754098, "num_tokens": 1270, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6187804478040616, "lm_q2_score": 0.5621765008857981, "lm_q1q2_score": 0.3478638269630346}} {"text": "///////////////////////////////////////////////////////////////////////////////\n// BSD 3-Clause License\n//\n// Copyright (C) 2019-2021, LAAS-CNRS, University of Edinburgh\n// Copyright note valid unless otherwise stated in individual files.\n// All rights reserved.\n///////////////////////////////////////////////////////////////////////////////\n\n#ifndef CROCODDYL_CORE_ACTUATION_BASE_HPP_\n#define CROCODDYL_CORE_ACTUATION_BASE_HPP_\n\n#include \n#include \n#include \n\n#include \"crocoddyl/core/fwd.hpp\"\n#include \"crocoddyl/core/mathbase.hpp\"\n#include \"crocoddyl/core/state-base.hpp\"\n#include \"crocoddyl/core/utils/exception.hpp\"\n\nnamespace crocoddyl {\n\n/**\n * @brief Abstract class for the actuation-mapping model\n *\n * The generalized torques \\f$\\boldsymbol{\\tau}\\in\\mathbb{R}^{nv}\\f$ can by any nonlinear function of the\n * control inputs \\f$\\mathbf{u}\\in\\mathbb{R}^{nu}\\f$, and state point \\f$\\mathbf{x}\\in\\mathbb{R}^{nx}\\f$, where\n * `nv`, `nu`, and `ndx` are the number of joints, dimension of the control input and state manifold,\n * respectively. Additionally, the generalized torques are also named as the actuation signals of our system.\n *\n * The main computations are carrying out in `calc()`, and `calcDiff()`, where the former computes actuation signal,\n * and the latter computes the Jacobians of the actuation-mapping function, i.e.,\n * \\f$\\frac{\\partial\\boldsymbol{\\tau}}{\\partial\\mathbf{x}}\\f$ and\n * \\f$\\frac{\\partial\\boldsymbol{\\tau}}{\\partial\\mathbf{u}}\\f$. Note that `calcDiff()` requires to run `calc()` first.\n *\n * \\sa `calc()`, `calcDiff()`, `createData()`\n */\ntemplate \nclass ActuationModelAbstractTpl {\n public:\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\n typedef _Scalar Scalar;\n typedef MathBaseTpl MathBase;\n typedef StateAbstractTpl StateAbstract;\n typedef ActuationDataAbstractTpl ActuationDataAbstract;\n typedef typename MathBase::VectorXs VectorXs;\n typedef typename MathBase::MatrixXs MatrixXs;\n\n /**\n * @brief Initialize the actuation model\n *\n * @param[in] state State description\n * @param[in] nu Dimension of control vector\n */\n ActuationModelAbstractTpl(boost::shared_ptr state, const std::size_t nu);\n virtual ~ActuationModelAbstractTpl();\n\n /**\n * @brief Compute the actuation signal from the state point \\f$\\mathbf{x}\\in\\mathbb{R}^{ndx}\\f$ and control input\n * \\f$\\mathbf{u}\\in\\mathbb{R}^{nu}\\f$\n *\n * @param[in] data Actuation data\n * @param[in] x State point \\f$\\mathbf{x}\\in\\mathbb{R}^{ndx}\\f$\n * @param[in] u Control input \\f$\\mathbf{u}\\in\\mathbb{R}^{nu}\\f$\n */\n virtual void calc(const boost::shared_ptr& data, const Eigen::Ref& x,\n const Eigen::Ref& u) = 0;\n\n /**\n * @brief Ignore the computation of the actuation signal\n *\n * It does not update the actuation signal as this function is used in the terminal nodes of an optimal\n * control problem.\n *\n * @param[in] data Actuation data\n * @param[in] x State point \\f$\\mathbf{x}\\in\\mathbb{R}^{ndx}\\f$\n */\n void calc(const boost::shared_ptr& data, const Eigen::Ref& x);\n\n /**\n * @brief Compute the Jacobians of the actuation function\n *\n * @param[in] data Actuation data\n * @param[in] x State point \\f$\\mathbf{x}\\in\\mathbb{R}^{ndx}\\f$\n * @param[in] u Control input \\f$\\mathbf{u}\\in\\mathbb{R}^{nu}\\f$\n */\n virtual void calcDiff(const boost::shared_ptr& data, const Eigen::Ref& x,\n const Eigen::Ref& u) = 0;\n\n /**\n * @brief Ignore the computation of the Jacobians of the actuation function\n *\n * It does not update the Jacobians of the actuation function as this function is used in the terminal\n * nodes of an optimal control problem.\n *\n * @param[in] data Actuation data\n * @param[in] x State point \\f$\\mathbf{x}\\in\\mathbb{R}^{ndx}\\f$\n */\n void calcDiff(const boost::shared_ptr& data, const Eigen::Ref& x);\n\n /**\n * @brief Create the actuation data\n *\n * @return the actuation data\n */\n virtual boost::shared_ptr createData();\n\n /**\n * @brief Return the dimension of the control input\n */\n std::size_t get_nu() const;\n\n /**\n * @brief Return the state\n */\n const boost::shared_ptr& get_state() const;\n\n /**\n * @brief Print information on the residual model\n */\n template \n friend std::ostream& operator<<(std::ostream& os, const ResidualModelAbstractTpl& model);\n\n /**\n * @brief Print relevant information of the residual model\n *\n * @param[out] os Output stream object\n */\n virtual void print(std::ostream& os) const;\n\n protected:\n std::size_t nu_; //!< Control dimension\n boost::shared_ptr state_; //!< Model of the state\n};\n\ntemplate \nstruct ActuationDataAbstractTpl {\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\n typedef _Scalar Scalar;\n typedef MathBaseTpl MathBase;\n typedef typename MathBase::VectorXs VectorXs;\n typedef typename MathBase::MatrixXs MatrixXs;\n\n template