{"text": "#include \n\n#include \n#include \n#include \n\nusing namespace QuantLib;\n\nvoid outputBasket(std::vector > basket,\n boost::shared_ptr termStructure) {\n\n std::cout << \"Calibration Basket:\" << std::endl;\n std::cout << \"expiry;maturityDate;expiryTime;maturityTime;nominal;rate;marketvol\" << std::endl;\n for(Size j=0;j helper = boost::dynamic_pointer_cast(basket[j]);\n Date endDate = helper->underlyingSwap()->fixedSchedule().dates().back();\n Real nominal = helper->underlyingSwap()->nominal();\n Real vol = helper->volatility()->value();\n Real rate = helper->underlyingSwap()->fixedRate();\n Date expiry = helper->swaption()->exercise()->date(0);\n Real expiryTime = termStructure->timeFromReference(expiry);\n Real endTime = termStructure->timeFromReference(endDate);\n // std::cout << expiry << \";\" << endDate << \";\" << expiryTime << \";\" << endTime << \";\" <<\n // nominal << \";\" << rate << \";\" << vol << std::endl;\n std::cout << expiry << \" & \" << endDate << \" & \" << expiryTime << \" & \" << endTime << \" & \" <<\n nominal << \" & \" << rate << \" \\\\\\\\\" << std::endl;\n }\n\n}\n\nvoid outputModel(std::vector& expiries, boost::shared_ptr model) {\n\n std::cout << \"Model parameters: \";\n std::cout << \"expiry;volatility\" << std::endl;\n for(Size i=0;iparams()[i] << std::endl;\n std::cout << expiries[i] << \" & \" << model->volatility()[i] << \" \\\\\\\\\" << std::endl;\n }\n std::cout << std::endl;\n\n}\n\nint main(int, char* []) {\n\n Date refDate(17,June,2013);\n Settings::instance().evaluationDate() = refDate;\n Date effective = TARGET().advance(refDate,2*Days);\n Date maturity = TARGET().advance(effective,10*Years);\n\n // market data: flat yts 3%, flat vol 20%\n\n Real rateLevel = 0.03;\n Real volLevel = 0.20;\n\n boost::shared_ptr ytsQuote0(new SimpleQuote(rateLevel));\n boost::shared_ptr ytsQuote1(new SimpleQuote(rateLevel+0.0010)); // 10bp shift up for dv01, dv02 calculation\n boost::shared_ptr ytsQuote2(new SimpleQuote(rateLevel-0.0010)); // 10bp shift down for dv01, dv02 calculation\n\n RelinkableHandle ytsQuote(ytsQuote0);\n\n Handle yts( boost::shared_ptr(new FlatForward(0,TARGET(),ytsQuote,\n Actual365Fixed())));\n\n boost::shared_ptr volQuote0(new SimpleQuote(volLevel));\n boost::shared_ptr volQuote1(new SimpleQuote(volLevel+0.01));\n\n RelinkableHandle volQuote(volQuote0);\n\n boost::shared_ptr swaptionVol(new ConstantSwaptionVolatility(0,TARGET(),\n ModifiedFollowing,volQuote,Actual365Fixed()));\n\n boost::shared_ptr iborIndex(new Euribor(6*Months,yts));\n boost::shared_ptr standardSwapBase(new EuriborSwapIsdaFixA(10*Years,yts));\n\n // spread Quote\n\n Real spreadLevel = 0.0100;\n boost::shared_ptr spreadQuote0(new SimpleQuote(spreadLevel));\n\n RelinkableHandle spreadQuote(spreadQuote0);\n\n // non standard swaption instrument (10y, amortizing nominal and step up coupon, yearly exercise dates)\n // we use the nonstandard swap and the nonstandard swaption for bond pricing, i.e. set the floating side to zero\n // receiver swap means we are long the bond\n // we are short the call right, so the rebate is positive\n\n std::vector fixedNominal(10), floatingNominal(20,0.0), fixedRate(10);\n for(Size i=0;i<10;i++) {\n fixedNominal[i] = 100.0;//-i*10.0;//-i*5000000;//(i>0 ? fixedNominal[i-1] : 100000000.0 )*1.075;\n floatingNominal[2*i] = floatingNominal[2*i+1] = 0.0; //fixedNominal[i];\n fixedRate[i] = 0.035;//+0.0030*i;\n }\n\n Schedule fixedSchedule(effective,maturity,1*Years,TARGET(),ModifiedFollowing,ModifiedFollowing,\n DateGeneration::Forward,false);\n Schedule floatingSchedule(effective,maturity,6*Months,TARGET(),ModifiedFollowing,ModifiedFollowing,\n DateGeneration::Forward,false);\n\n boost::shared_ptr underlying(new NonstandardSwap(VanillaSwap::Receiver,fixedNominal,floatingNominal,\n fixedSchedule,fixedRate,Thirty360(),floatingSchedule,\n iborIndex,1.0,0.0,Actual360(),true,true));\n\n std::vector exerciseDates;\n std::vector rebates;\n for(Size i=1;i<10;i++) {\n exerciseDates.push_back(TARGET().advance(fixedSchedule[i],-2*Days));\n rebates.push_back(-100.0);\n }\n\n //BermudanExercise exerciseTmp(exerciseDates, false);\n boost::shared_ptr exercise =\n boost::make_shared(\n BermudanExercise(exerciseDates, false), rebates, 2, TARGET(),\n Following);\n\n boost::shared_ptr swaption(\n new NonstandardSwaption(underlying, exercise));\n\n // pricing of vanilla bond part\n\n std::cout << \"============================================================\" << std::endl;\n std::cout << \"Vanilla part pricing\" << std::endl;\n std::cout << \"============================================================\" << std::endl;\n\n Leg vanilla = underlying->leg(0);\n Leg other = underlying->leg(1);\n\n Real vanillaNpv = CashFlows::npv(vanilla,*yts,spreadQuote->value(),yts->dayCounter(),Continuous,NoFrequency,false);\n Real otherNpv = CashFlows::npv(other,*yts,spreadQuote->value(),yts->dayCounter(),Continuous,NoFrequency,false);\n\n std::cout << \"npv = \" << vanillaNpv << \" (other = \" << otherNpv << \")\" << std::endl;\n\n // gsr model (1% mean reversion, intially 1% vol)\n\n exerciseDates.pop_back();\n std::vector stepDates(exerciseDates);\n std::vector vols(exerciseDates.size()+1,0.01);\n std::vector reversions(exerciseDates.size()+1,0.01);\n\n boost::shared_ptr gsr(new Gsr(yts,stepDates,vols,reversions,50.0));\n\n // engines for nonstandard swaption and standard swaption\n\n // this engine is used for standard swaptions used in model calibration\n boost::shared_ptr standardEngine(new Gaussian1dSwaptionEngine(gsr));\n // this engine is used for the non standard swaption\n boost::shared_ptr nonStandardEngine(new Gaussian1dNonstandardSwaptionEngine(gsr,64,7.0,true,false,\n spreadQuote));\n\n swaption->setPricingEngine(nonStandardEngine);\n\n std::cout.precision(6);\n std::cout << std::fixed;\n\n std::cout << \"============================================================\" << std::endl;\n std::cout << \"Model is not calibrated\" << std::endl;\n std::cout << \"============================================================\" << std::endl;\n outputModel(stepDates,gsr);\n\n std::cout << \"Calculate calibration basket\" << std::endl;\n std::vector > basket = swaption->calibrationBasket(standardSwapBase,swaptionVol);\n for(Size i=0;isetPricingEngine(standardEngine);\n outputBasket(basket,*gsr->termStructure());\n\n std::cout << \"Calibrate the model to the initial basket\" << std::endl;\n LevenbergMarquardt lm;\n EndCriteria ec(2000,200,1E-8,1E-8,1E-8);\n gsr->calibrateVolatilitiesIterative(basket,lm,ec);\n outputModel(stepDates,gsr);\n\n std::cout << \"Calculate calibration basket\" << std::endl;\n\n std::vector > basket2 = swaption->calibrationBasket(standardSwapBase,swaptionVol);\n for(Size i=0;isetPricingEngine(standardEngine);\n outputBasket(basket2,*gsr->termStructure());\n\n std::cout << \"Calibrate the model to the second basket\" << std::endl;\n\n gsr->calibrateVolatilitiesIterative(basket2,lm,ec);\n outputModel(stepDates,gsr);\n\n std::cout << \"Price the nonstandard swaption\" << std::endl;\n\n Real npv0 = swaption->NPV();\n\n std::cout << \"Shift the rate curve by 10bp up, down and reprice to compute delta, gamma\" << std::endl;\n\n ytsQuote.linkTo(ytsQuote1);\n Real npv1 = swaption->NPV();\n ytsQuote.linkTo(ytsQuote2);\n Real npv2 = swaption->NPV();\n ytsQuote.linkTo(ytsQuote0);\n\n Real npv3 = swaption->NPV();\n\n std::cout << \"NPV(-10bp) = \" << npv2 << \" NPV(0) = \" << npv0 << \" NPV(+10bp) = \" << npv1 << std::endl;\n std::cout << \"DV01 = \" << (npv1-npv2) / 20.0 << std::endl;\n std::cout << \"DV02 = \" << (npv1-2.0*npv0+npv2) / 100.0 << std::endl;\n std::cout << \"Vega = \" << (npv3-npv0) << std::endl;\n\n std::cout << \"============================================================\" << std::endl;\n std::cout << \"Compute delta, gamma with model recalibration\" << std::endl;\n std::cout << \"============================================================\" << std::endl;\n\n gsr->calibrateVolatilitiesIterative(basket2,lm,ec);\n outputModel(stepDates,gsr);\n npv0 = swaption->NPV();\n\n ytsQuote.linkTo(ytsQuote1);\n gsr->calibrateVolatilitiesIterative(basket2,lm,ec); outputModel(stepDates,gsr);\n npv1 = swaption->NPV();\n ytsQuote.linkTo(ytsQuote2);\n gsr->calibrateVolatilitiesIterative(basket2,lm,ec); outputModel(stepDates,gsr);\n npv2 = swaption->NPV();\n ytsQuote.linkTo(ytsQuote0);\n\n for(Size i=0;i(*basket2[i]->volatility())\n ->setValue(volQuote1->value());\n gsr->calibrateVolatilitiesIterative(basket2,lm,ec); outputModel(stepDates,gsr);\n npv3 = swaption->NPV();\n for(Size i=0;i(*basket2[i]->volatility())\n ->setValue(volQuote0->value());\n\n std::cout << \"NPV(-10bp) = \" << npv2 << \" NPV(0) = \" << npv0 << \" NPV(+10bp) = \" << npv1 << std::endl;\n std::cout << \"DV01 = \" << (npv1-npv2) / 20.0 << std::endl;\n std::cout << \"DV02 = \" << (npv1-2.0*npv0+npv2) / 100.0 << std::endl;\n std::cout << \"Vega = \" << (npv3-npv0) << std::endl;\n\n std::cout << \"============================================================\" << std::endl;\n std::cout << \"Compute delta, gamma with basket recalculation and recalibration\" << std::endl;\n std::cout << \"============================================================\" << std::endl;\n\n gsr->calibrateVolatilitiesIterative(basket2,lm,ec);\n outputModel(stepDates,gsr);\n npv0 = swaption->NPV();\n\n ytsQuote.linkTo(ytsQuote1);\n gsr->calibrateVolatilitiesIterative(basket2,lm,ec); outputModel(stepDates,gsr);\n std::vector > basket3a = swaption->calibrationBasket(standardSwapBase,swaptionVol);\n for(Size i=0;isetPricingEngine(standardEngine);\n outputBasket(basket3a,*gsr->termStructure());\n gsr->calibrateVolatilitiesIterative(basket3a,lm,ec); outputModel(stepDates,gsr);\n npv1 = swaption->NPV();\n\n ytsQuote.linkTo(ytsQuote2);\n\n gsr->calibrateVolatilitiesIterative(basket2,lm,ec); outputModel(stepDates,gsr);\n std::vector > basket3b = swaption->calibrationBasket(standardSwapBase,swaptionVol);\n for(Size i=0;isetPricingEngine(standardEngine);\n outputBasket(basket3b,*gsr->termStructure());\n gsr->calibrateVolatilitiesIterative(basket3b,lm,ec); outputModel(stepDates,gsr);\n npv2 = swaption->NPV();\n\n ytsQuote.linkTo(ytsQuote0);\n\n for(Size i=0;i(*basket2[i]->volatility())->\n setValue(volQuote1->value());\n volQuote.linkTo(volQuote1);\n gsr->calibrateVolatilitiesIterative(basket2,lm,ec); outputModel(stepDates,gsr);\n std::vector > basket3c = swaption->calibrationBasket(standardSwapBase,swaptionVol);\n for(Size i=0;isetPricingEngine(standardEngine);\n outputBasket(basket3c,*gsr->termStructure());\n gsr->calibrateVolatilitiesIterative(basket3c,lm,ec); outputModel(stepDates,gsr);\n npv3 = swaption->NPV();\n for(Size i=0;i(*basket2[i]->volatility())->\n setValue(volQuote0->value());\n volQuote.linkTo(volQuote0);\n\n\n std::cout << \"NPV(-10bp) = \" << npv2 << \" NPV(0) = \" << npv0 << \" NPV(+10bp) = \" << npv1 << std::endl;\n std::cout << \"DV01 = \" << (npv1-npv2) / 20.0 << std::endl;\n std::cout << \"DV02 = \" << (npv1-2.0*npv0+npv2) / 100.0 << std::endl;\n std::cout << \"Vega = \" << (npv3-npv0) << std::endl;\n\n\n\n}\n", "meta": {"hexsha": "f1f28dcd6666f032b5b215ff4ad6b9825a3dbb45", "size": 13199, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Examples/CallableBonds2/CallableBonds2.cpp", "max_stars_repo_name": "universe1987/QuantLib", "max_stars_repo_head_hexsha": "bbb0145aff285853755b9f6ed013f53a41163acb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2016-03-28T15:05:23.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-17T23:05:57.000Z", "max_issues_repo_path": "Examples/CallableBonds2/CallableBonds2.cpp", "max_issues_repo_name": "universe1987/QuantLib", "max_issues_repo_head_hexsha": "bbb0145aff285853755b9f6ed013f53a41163acb", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2015-02-02T20:32:43.000Z", "max_issues_repo_issues_event_max_datetime": "2015-02-02T20:32:43.000Z", "max_forks_repo_path": "Examples/CallableBonds2/CallableBonds2.cpp", "max_forks_repo_name": "pcaspers/quantlib", "max_forks_repo_head_hexsha": "bbb0145aff285853755b9f6ed013f53a41163acb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2015-01-26T14:50:24.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-23T07:41:30.000Z", "avg_line_length": 47.4784172662, "max_line_length": 124, "alphanum_fraction": 0.615425411, "num_tokens": 3653, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434978390747, "lm_q2_score": 0.6477982315512488, "lm_q1q2_score": 0.4999988529344827}} {"text": "\n# include \n# include \n# include \n# include \n# include \n# include \n# include \n# include \n# include \n# include \n#include \n\n#include \n\n\nusing namespace std;\n\n\nvector split(string& input, char delimiter)\n{\n istringstream stream(input);\n string field;\n vector result;\n while (getline(stream, field, delimiter)) {\n result.push_back(field);\n }\n return result;\n}\n\nint get_dataset(const char* file_path, int*& ou_array, int*& ov_array, float*& y0_array)\n{\t\n\n\tvector ou;\n\tvector ov;\n\tvector y0;\n\tifstream ifs(file_path);\n\tstring line;\n\twhile(getline(ifs,line)){\n\n\t\tstd::vector strvec = split(line, ' ');\n\n\t\tou.push_back( stoi(strvec.at(0)) );\n\t\tov.push_back( stoi(strvec.at(1)) );\n\t\ty0.push_back( stof(strvec.at(2)) );\n\n\n\t}\n\tint k = ou.size();\n\tou_array = new int[k];\n\tov_array = new int[k];\n\ty0_array = new float[k];\n\tfor (int i = 0; i < k; ++i)\n\t{\n\t\tou_array[i] = ou[i];\n\t\tov_array[i] = ov[i];\n\t\ty0_array[i] = (float)y0[i];\n\t}\n\n\treturn k;\n}\n\nvoid show_vec_array(const std::vector >& array)\n{\n\tfor (int i = 0; i < array.size(); ++i)\n\t{\n\t\t\n\t\t// std::vector array_i = array[i];\n\t\tfor (int j = 0; j < array[i].size(); ++j)\n\t\t{\n\t\t\tprintf(\"%i \", array[i][j]);\n\t\t}\n\t\tprintf(\"\\n\");\n\t}\n}\n\nvoid show_array(int N, int M, float** array)\n{\n\tfor (int i = 0; i < N; ++i)\n\t{\n\t\tfor (int j = 0; j < M; ++j)\n\t\t{\n\t\t\tprintf(\"%f \", array[i][j]);\n\t\t}\n\t\tprintf(\"\\n\");\n\t}\n}\n\nint maximum_value(int* array, int size)\n{\n\tint max = array[0];\n\tfor (int i = 0; i < size; ++i)\n\t{\n\t\tif (max < array[i])\n\t\t{\n\t\t\tmax = array[i];\n\t\t}\n\t}\n\treturn max;\n}\n\nfloat mean_matrix(float** matrix, int N, int M)\n{\n\tfloat sm = 0;\n\tfor (int i = 0; i < N; ++i)\n\t{\n\t\tfor (int j = 0; j < M; ++j)\n\t\t{\n\t\t\tsm += matrix[i][j];\n\t\t}\n\t}\n\tsm = sm/(float)(N*M);\n\treturn sm;\n}\n\nfloat mean_array(float* array, int size)\n{\n\tfloat sm = 0;\n\tfor (int i = 0; i < size; ++i)\n\t{\n\t\tsm += array[i];\n\t}\n\treturn sm/(float)size;\n}\n\nfloat std_array(float* array, int size, float mean)\n{\n\tfloat sm = 0;\n\tfor (int i = 0; i < size; ++i)\n\t{\n\t\tsm += pow(array[i]-mean, 2);\n\t}\n\tsm = sm / (float)size;\n\tsm = sqrt(sm);\n\treturn sm;\n}\n\n\ntuple< vector< vector >, vector< vector >, vector< vector >, vector< vector > > getNb(int* ou, int* ov,int N,int M,int k)\n{\n\tvector< vector > nbu;\n\tvector< vector > nbv;\n\tvector< vector > nbul;\n\tvector< vector > nbvl;\n\n\tnbu = vector>(N, vector(0, 0));\n\tnbul = vector>(N, vector(0, 0));\n\tnbv = vector>(M, vector(0, 0));\n\tnbvl = vector>(M, vector(0, 0));\n\n\tfor (int i = 0; i < k; ++i)\n\t{\n\t\tint u_ind = ou[i];\n\t\tint v_ind = ov[i];\n\n\t\tnbu[u_ind].push_back(v_ind);\n\t\tnbul[u_ind].push_back(i);\n\n\t\tnbv[v_ind].push_back(u_ind);\n\t\tnbvl[v_ind].push_back(i);\n\t}\n\n\treturn std::forward_as_tuple(nbu, nbv, nbul, nbvl);\n\n}\n\ntuple< float**, float**, int, float* > cbmf(int N, int M, int* ou, int* ov, const vector>& nbu, const vector>& nbv, const vector>& nbul, const vector>& nbvl, int k, float* y0, int maxCnt, float gam, double conv, int R, float lam, int* te_u, int* te_v, float* te_y0, int k_te, float mean, float std)\n{\n\n\tstd::random_device rd;\n\tstd::mt19937 mt(rd());\n\tstd::uniform_real_distribution rdm(0.0, 1.0);\n\n\tfloat *rmse_arr = new float[maxCnt];\n\n\t// allocating memory\n\tfloat **a_hat = new float*[k];\n\tfloat **b_hat = new float*[k];\n\tfloat **c_hat = new float*[k];\n\tfloat **d_hat = new float*[k];\n\tfloat **alf = new float*[k];\n\tfloat **beta = new float*[k];\n\tfloat **gamma = new float*[k];\n\tfloat **delta = new float*[k];\n\tfor (int i = 0; i < k; ++i)\n\t{\n\t\ta_hat[i] = new float[R];\n\t\tb_hat[i] = new float[R];\n\t\tc_hat[i] = new float[R];\n\t\td_hat[i] = new float[R];\n\t\talf[i] = new float[R];\n\t\tbeta[i] = new float[R];\n\t\tgamma[i] = new float[R];\n\t\tdelta[i] = new float[R];\n\t}\n\n\n\tfloat **a_m_hat = new float*[N];\n\tfloat **b_m_hat = new float*[N];\n\tfloat **c_m_hat = new float*[M];\n\tfloat **d_m_hat = new float*[M];\n\tfor (int i = 0; i < N; ++i)\n\t{\n\t\ta_m_hat[i] = new float[R];\n\t\tb_m_hat[i] = new float[R];\n\t}\n\tfor (int i = 0; i < M; ++i)\n\t{\n\t\tc_m_hat[i] = new float[R];\n\t\td_m_hat[i] = new float[R];\n\t}\n\n\tfloat *alf_m = new float[k];\n float *beta_m = new float[k];\n float *gamma_m = new float[k];\n float *delta_m = new float[k];\n\n float **u = new float*[N];\n for (int i = 0; i < N; ++i)\n {\n \tu[i] = new float[R];\n }\n float **v = new float*[M];\n for (int i = 0; i < M; ++i)\n {\n \tv[i] = new float[R];\n }\n\n\n auto t0 = std::chrono::system_clock::now();\n\n\n // initialize u and v\n\tarma::sp_mat spmx(N,M);\n for (int i = 0; i < k; ++i)\n {\n \tspmx(ou[i], ov[i]) = y0[i];\n }\n arma::mat U;\n\tarma::vec s;\n\tarma::mat V;\n\n\tsvds(U, s, V, spmx, R);\n\n\ts = arma::sqrt(s);\n\tarma::mat S = diagmat(s);\n\n\tU = U*S;\n\tV = V*S;\n\n\n for (int i = 0; i < N; ++i)\n {\n \tfor (int r = 0; r < R; ++r)\n \t{\n \t\tu[i][r] = U(i,r);\n \t}\n }\n for (int i = 0; i < M; ++i)\n {\n \tfor (int r = 0; r < R; ++r)\n \t{\n \t\tv[i][r] = V(i,r);\n \t}\n }\n\n\n\tfor (int i = 0; i < k; ++i)\n\t{\n\t\tfor (int j = 0; j < R; ++j)\n\t\t{\n\t\t\ta_hat[i][j] = rdm(mt)*5;\n\t\t\tb_hat[i][j] = -a_hat[i][j]*u[ou[i]][j];\n\t\t\t\n\t\t\tc_hat[i][j] = rdm(mt)*5;\n\t\t\td_hat[i][j] = -c_hat[i][j]*v[ov[i]][j];\n\t\t}\n\t}\n\n\n\tfor (int i = 0; i < N; ++i)\n\t{\n\t\tfor (int r = 0; r < R; ++r)\n\t\t{\n\t\t\t\n\t\t\tfloat a_sm = 0;\n\t\t\tfloat b_sm = 0;\n\t\t\tfor (const auto& nb: nbul[i])\n\t\t\t{\n\t\t\t\ta_sm += a_hat[nb][r];\n\t\t\t\tb_sm += b_hat[nb][r];\n\t\t\t}\n\t\t\ta_m_hat[i][r] = a_sm + lam;\n\t\t\tb_m_hat[i][r] = b_sm;\n\t\t}\n\t}\n\tfor (int i = 0; i < M; ++i)\n\t{\n\t\tfor (int r = 0; r < R; ++r)\n\t\t{\n\t\t\t\n\t\t\tfloat c_sm = 0;\n\t\t\tfloat d_sm = 0;\n\t\t\tfor (const auto& nb: nbvl[i])\n\t\t\t{\n\t\t\t\tc_sm += c_hat[nb][r];\n\t\t\t\td_sm += d_hat[nb][r];\n\t\t\t}\n\t\t\tc_m_hat[i][r] = c_sm + lam;\n\t\t\td_m_hat[i][r] = d_sm;\n\t\t}\n\t}\n\n\n\tfor (int i = 0; i < k; ++i)\n\t{\n\t\tfor (int r = 0; r < R; ++r)\n\t\t{\n\t\t\tfloat vov = v[ov[i]][r];\n\t\t\tfloat vov2 = pow(vov, 2);\n\t\t\tfloat uou = u[ou[i]][r];\n \t\tfloat uou2 = pow(uou, 2);\n\t\t\talf[i][r] = vov2 / ( a_m_hat[ou[i]][r] - a_hat[i][r] );\n\t\t\tbeta[i][r] = ( b_m_hat[ou[i]][r] - b_hat[i][r] ) * vov / ( a_m_hat[ou[i]][r] - a_hat[i][r] );\n\t\t\tgamma[i][r] = uou2 /( c_m_hat[ov[i]][r] - c_hat[i][r] );\n\t\t\tdelta[i][r] = ( d_m_hat[ov[i]][r] - d_hat[i][r] ) * uou / ( c_m_hat[ov[i]][r] - c_hat[i][r] );\n\t\t}\n\t}\n\n\tfloat sm1;\n\tfloat sm2;\n\tfloat sm3;\n\tfloat sm4;\n\tfor (int i = 0; i < k; ++i)\n\t{\t\n\t\tsm1 = 0;\n\t\tsm2 = 0;\n\t\tsm3 = 0;\n\t\tsm4 = 0;\n\t\tfor (int r = 0; r < R; ++r)\n\t\t{\n\t\t\tsm1 += alf[i][r];\n\t\t\tsm2 += beta[i][r];\n\t\t\tsm3 += gamma[i][r];\n\t\t\tsm4 += delta[i][r];\n\t\t}\n\t\talf_m[i] = sm1 + 1;\n\t\tbeta_m[i] = sm2;\n\t\tgamma_m[i] = sm3 + 1;\n\t\tdelta_m[i] = sm4;\n\t}\n\t\n\n\n\t ///////////////\n /* main loop */\n ///////////////\n int cnt;\n float rmse = 0.0;\n for (cnt = 0; cnt < maxCnt; ++cnt)\n {\n\n \t/* u update */\n\n\n \t// update alf and beta\n \tfloat dm;\n \tfloat vov;\n \tfloat vov2;\n \tfor (int i = 0; i < k; ++i)\n\t\t{\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\tvov = v[ov[i]][r];\n\t\t\t\tvov2 = pow(vov, 2);\n\t\t\t\tdm = a_m_hat[ou[i]][r] - a_hat[i][r];\n\n\t\t\t\talf[i][r] = vov2 / dm;\n\t\t\t\tbeta[i][r] = ( b_m_hat[ou[i]][r] - b_hat[i][r] ) * vov / dm;\n\t\t\t}\n\t\t}\n\n\n\t\t// update alf_m and beta_m\n\t\tfloat sm1;\n\t\tfloat sm2;\n\t\tfor (int i = 0; i < k; ++i)\n\t\t{\t\n\t\t\tsm1 = 0;\n\t\t\tsm2 = 0;\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\tsm1 += alf[i][r];\n\t\t\t\tsm2 += beta[i][r];\n\t\t\t}\n\t\t\talf_m[i] = sm1 + 1;\n\t\t\tbeta_m[i] = sm2 + y0[i];\n\t\t}\n\n\n \t// update a and b hat\n \tfor (int i = 0; i < k; ++i)\n \t{\t\n \t\tfor (int r = 0; r < R; ++r)\n \t\t{\n \t\t\tvov = v[ov[i]][r];\n \t\t\tvov2 = pow(vov, 2);\n \t\t\tdm = alf_m[i] - alf[i][r];\n\n \t\t\ta_hat[i][r] = (1-gam)*a_hat[i][r] + gam*vov2/dm;\n \t\t\tb_hat[i][r] = (1-gam)*b_hat[i][r] - gam*( beta_m[i] - beta[i][r] )*vov/dm;\n \t\t}\n \t}\n\n\n \t// update a and b marginalized hat\n \tfloat a_sm;\n \tfloat b_sm;\n \tfor (int i = 0; i < N; ++i)\n\t\t{\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\ta_sm = 0;\n\t\t\t\tb_sm = 0;\n\t\t\t\tfor (const auto& nb: nbul[i])\n\t\t\t\t{\n\t\t\t\t\ta_sm += a_hat[nb][r];\n\t\t\t\t\tb_sm += b_hat[nb][r];\n\t\t\t\t}\n\t\t\t\ta_m_hat[i][r] = a_sm + lam;\n\t\t\t\tb_m_hat[i][r] = b_sm;\n\t\t\t}\n\t\t}\n\n\n\t\t// update u\n\t\tfor (int i = 0; i < N; ++i)\n\t\t{\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\tu[i][r] = -b_m_hat[i][r]/a_m_hat[i][r];\n\t\t\t}\n\t\t}\n\n\n\n\t\t/* update v */\n\n\t\t// update gamma and delta\n\t\tfloat uou;\n\t\tfloat uou2;\n\t\tfor (int i = 0; i < k; ++i)\n\t\t{\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\tuou = u[ou[i]][r];\n\t \t\tuou2 = pow(uou, 2);\n\t \t\tdm = c_m_hat[ov[i]][r] - c_hat[i][r];\n\n\t\t\t\tgamma[i][r] = uou2 /dm;\n\t\t\t\tdelta[i][r] = ( d_m_hat[ov[i]][r] - d_hat[i][r] ) * uou / dm;\n\t\t\t}\n\t\t}\n\n\n\t\t// update gamma_m and delta_m\n\t\tfor (int i = 0; i < k; ++i)\n\t\t{\t\n\t\t\tsm1 = 0.0;\n\t\t\tsm2 = 0.0;\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\tsm1 += gamma[i][r];\n\t\t\t\tsm2 += delta[i][r];\n\t\t\t}\n\t\t\tgamma_m[i] = sm1 + 1;\n\t\t\tdelta_m[i] = sm2 + y0[i];\n\t\t}\n\n\n\t\t// update c and d hat\n \tfor (int i = 0; i < k; ++i)\n \t{\n \t\tfor (int r = 0; r < R; ++r)\n \t\t{\n \t\t\tuou = u[ou[i]][r];\n \t\t\tuou2 = pow(uou, 2);\n \t\t\tdm = gamma_m[i] - gamma[i][r];\n\n \t\t\tc_hat[i][r] = (1-gam)*c_hat[i][r] + gam*uou2/dm;\n \t\t\td_hat[i][r] = (1-gam)*d_hat[i][r] - gam*( delta_m[i] - delta[i][r] )*uou/dm;\n \t\t}\n \t}\n\n \t// update c and d marginalized hat\n \tfloat c_sm;\n \tfloat d_sm;\n \tfor (int i = 0; i < M; ++i)\n\t\t{\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\t\n\t\t\t\tc_sm = 0;\n\t\t\t\td_sm = 0;\n\t\t\t\tfor (const auto& nb: nbvl[i])\n\t\t\t\t{\n\t\t\t\t\tc_sm += c_hat[nb][r];\n\t\t\t\t\td_sm += d_hat[nb][r];\n\t\t\t\t}\n\t\t\t\tc_m_hat[i][r] = c_sm + lam;\n\t\t\t\td_m_hat[i][r] = d_sm;\n\t\t\t}\n\t\t}\n\n\t\t\n\n\t\t// update v\n\t\tfor (int i = 0; i < M; ++i)\n\t\t{\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\tv[i][r] = -d_m_hat[i][r]/c_m_hat[i][r];\n\t\t\t}\n\t\t}\n\n\n\n\t\t// calulate test rmse\n\t\tfloat mse = 0;\n\t\tfor (int i = 0; i < k_te; ++i)\n\t\t{\n\n\t\t\tfloat inf_y0 = 0;\n\t\t\tint u_i = te_u[i];\n\t\t\tint v_i = te_v[i];\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\tinf_y0 += u[u_i][r]*v[v_i][r];\n\t\t\t}\n\t\t\tinf_y0 = inf_y0*std + mean;\n\t\t\tmse += pow(inf_y0 - te_y0[i], 2);\n\n\t\t}\n\t\tmse = mse / (float)k_te;\n\t\tfloat new_rmse = sqrt(mse);\n\t\tfloat dif = abs(new_rmse-rmse);\n\n\t\trmse_arr[cnt] = new_rmse;\n\n\t\tif (cnt%1 == 0)\n\t\t{\n\t\t\tprintf(\"iteration:%d \", cnt);\n\t\t\tprintf(\"rmse:%f\\n\", new_rmse);\n\t\t}\n\n\t\trmse = new_rmse;\n\t\tif (dif < conv || dif != dif)\n\t\t{\n\t\t\tbreak;\n\t\t}\n\t\t\n\n\n } // end main loop\n\n return std::forward_as_tuple(u, v, cnt, rmse_arr);\n\n}\n\n\n\ntuple< float**, float**, int, float* > approx_cbmf(int N, int M, int* ou, int* ov, const vector>& nbu, const vector>& nbv, const vector>& nbul, const vector>& nbvl, int k, float* y0, int maxCnt, float gam, double conv, int R, float lam, int* te_u, int* te_v, float* te_y0, int k_te, float mean, float std)\n{\n\n\tstd::random_device rd;\n\tstd::mt19937 mt(rd());\n\tstd::uniform_real_distribution rdm(0.0, 1.0);\n\tstd::normal_distribution g_rdm(0.0,1.0);\n\n\tfloat *rmse_arr = new float[maxCnt];\n\n\t// allocating memory\n\tfloat *a = new float[k];\n\tfloat *b = new float[k];\n\tfloat *c = new float[k];\n\tfloat *d = new float[k];\n\n\n\tfloat **a_hat = new float*[N];\n\tfloat **b_hat = new float*[N];\n\tfloat **u = new float*[N];\n\tfloat **c_hat = new float*[M];\n\tfloat **d_hat = new float*[M];\n\tfloat **v = new float*[M];\n\tfor (int i = 0; i < N; ++i)\n\t{\n\t\ta_hat[i] = new float[R];\n\t\tb_hat[i] = new float[R];\n\t\tu[i] = new float[R];\n\t}\n\tfor (int i = 0; i < M; ++i)\n\t{\n\t\tc_hat[i] = new float[R];\n\t\td_hat[i] = new float[R];\n\t\tv[i] = new float[R];\n\t}\n\n\n arma::sp_mat spmx(N,M);\n for (int i = 0; i < k; ++i)\n {\n \tspmx(ou[i], ov[i]) = y0[i];\n }\n arma::mat U;\n\tarma::vec s;\n\tarma::mat V;\n\n\tsvds(U, s, V, spmx, R);\n\n\ts = arma::sqrt(s);\n\tarma::mat S = diagmat(s);\n\n\tU = U*S;\n\tV = V*S;\n\n\n for (int i = 0; i < N; ++i)\n {\n \tfor (int r = 0; r < R; ++r)\n \t{\n \t\tu[i][r] = U(i,r);\n \t}\n }\n for (int i = 0; i < M; ++i)\n {\n \tfor (int r = 0; r < R; ++r)\n \t{\n \t\tv[i][r] = V(i,r);\n \t}\n }\n\n\n // initialize a,b,c,d hat\n\tfor (int i = 0; i < N; ++i)\n\t{\n\t\tfor (int j = 0; j < R; ++j)\n\t\t{\n\t\t\ta_hat[i][j] = rdm(mt)+100;\n\t\t\tb_hat[i][j] = (a_hat[i][j])*u[i][j];\n\t\t}\n\t}\n\tfor (int i = 0; i < M; ++i)\n\t{\n\t\tfor (int j = 0; j < R; ++j)\n\t\t{\n\t\t\tc_hat[i][j] = rdm(mt)+100;\n\t\t\td_hat[i][j] = (c_hat[i][j])*v[i][j];\n\t\t}\n\t}\n\n\t// initialize alf, beta, gamma, delta\n\tfor (int i = 0; i < k; ++i)\n\t{\n\t\ta[i] = rdm(mt);\n\t\tb[i] = rdm(mt);\n\t\tc[i] = rdm(mt);\n\t\td[i] = rdm(mt);\n\t}\n\n\n\t ///////////////\n /* main loop */\n ///////////////\n printf(\"main loop\\n\");\n float vov;\n\tfloat vov2;\n\tfloat uou;\n\tfloat uou2;\n float sm1;\n float sm2;\n int cnt;\n float rmse = 0.0;\n for (cnt = 0; cnt < maxCnt; ++cnt)\n {\n\n \t/* u update */\n\n \t// update alf and beta\n \tfor (int i = 0; i < k; ++i)\n\t\t{\t\n\t\t\tsm1 = 0;\n\t\t\tsm2 = 0;\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\tvov = v[ov[i]][r];\n\t\t\t\tuou = u[ou[i]][r];\n\t\t\t\tvov2 = pow(vov, 2);\n\n\n\t\t\t\t// a\n\t\t\t\tsm1 += vov2/(a_hat[ou[i]][r]+lam);\n\t\t\t\t// b\n\t\t\t\tsm2 += vov*uou;\n\t\t\t}\n\t\t\tb[i] = ( y0[i]-sm2+a[i]*b[i] ) / ( 1+a[i] );\n\t\t\ta[i] = sm1;\n\t\t\t\n\t\t}\n\n\n\n \t// update a and b hat\n \tfor (int i = 0; i < N; ++i)\n\t\t{\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\tsm1 = 0;\n\t\t\t\tsm2 = 0;\n\t\t\t\tfor (const auto& nb: nbul[i])\n\t\t\t\t{\n\t\t\t\t\tvov = v[ov[nb]][r];\n\t\t\t\t\tvov2 = pow(vov, 2);\n\t\t\t\t\tuou = u[i][r];\n\n\t\t\t\t\t// a_hat\n\t\t\t\t\tsm1 += vov2/(1+a[nb]);\n\n\t\t\t\t\t// b_hat\n\t\t\t\t\tsm2 += b[nb]*vov;\n\t\t\t\t\tsm2 += uou*vov2/(1+a[nb]);\n\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tb_hat[i][r] = (1-gam)*b_hat[i][r] + gam*sm2;\n\t\t\t\ta_hat[i][r] = (1-gam)*a_hat[i][r] + gam*sm1;\n\n\t\t\t\t// update u\n\t\t\t\tu[i][r] = b_hat[i][r]/(a_hat[i][r]+lam);\n\n\t\t\t}\n\t\t}\n\n\n\n\t\t/* update v */\n\n\t\t// update c and d\n \tfor (int i = 0; i < k; ++i)\n\t\t{\t\n\t\t\tsm1 = 0;\n\t\t\tsm2 = 0;\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\tvov = v[ov[i]][r];\n\t\t\t\tuou = u[ou[i]][r];\n\t\t\t\tuou2 = pow(uou, 2);\n\n\t\t\t\t// a\n\t\t\t\tsm1 += uou2/(c_hat[ov[i]][r]+lam);\n\t\t\t\t// b\n\t\t\t\tsm2 += vov*uou;\n\t\t\t}\n\t\t\td[i] = ( y0[i]-sm2+c[i]*d[i] ) / ( 1+c[i] );\n\t\t\tc[i] = sm1;\n\t\t\t\n\t\t}\n\n\n\t\t// update c and d hat\n \tfor (int i = 0; i < M; ++i)\n\t\t{\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\tsm1 = 0;\n\t\t\t\tsm2 = 0;\n\t\t\t\tfor (const auto& nb: nbvl[i])\n\t\t\t\t{\n\t\t\t\t\t// vov = v[ov[nb]][r];\n\t\t\t\t\tvov = v[i][r];\n\t\t\t\t\tuou = u[ou[nb]][r];\n\t\t\t\t\tuou2 = pow(uou, 2);\n\n\t\t\t\t\t// a_hat\n\t\t\t\t\tsm1 += uou2/(1+c[nb]);\n\n\t\t\t\t\t// b_hat\n\t\t\t\t\tsm2 += d[nb]*uou;\n\t\t\t\t\tsm2 += vov*uou2/(1+c[nb]);\n\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\td_hat[i][r] = (1-gam)*d_hat[i][r] + gam*sm2;\n\t\t\t\tc_hat[i][r] = (1-gam)*c_hat[i][r] + gam*sm1;\n\n\t\t\t\t// update v\n\t\t\t\tv[i][r] = d_hat[i][r]/(c_hat[i][r]+lam);\n\t\t\t}\n\t\t}\n\t\t\n\n\n\n\t\t// calulate test rmse\n\t\tfloat mse = 0;\n\t\tfor (int i = 0; i < k_te; ++i)\n\t\t{\n\n\t\t\tfloat inf_y0 = 0;\n\t\t\tint u_i = te_u[i];\n\t\t\tint v_i = te_v[i];\n\t\t\tfor (int r = 0; r < R; ++r)\n\t\t\t{\n\t\t\t\tinf_y0 += u[u_i][r]*v[v_i][r];\n\t\t\t}\n\t\t\tinf_y0 = inf_y0*std + mean;\n\n\t\t\tmse += pow(inf_y0 - te_y0[i], 2);\n\n\t\t}\n\t\tmse = mse / (float)k_te;\n\t\tfloat new_rmse = sqrt(mse);\n\t\tfloat dif = abs(new_rmse-rmse);\n\n\t\trmse_arr[cnt] = new_rmse;\n\n\t\tif (cnt%1 == 0)\n\t\t{\n\t\t\tprintf(\"iteration:%d \", cnt);\n\t\t\tprintf(\"rmse:%f\\n\", new_rmse);\n\t\t}\n\n\t\trmse = new_rmse;\n\t\tif (dif < conv || dif != dif)\n\t\t{\n\t\t\tbreak;\n\t\t}\n\n\n } // end main loop\n\n return std::forward_as_tuple(u, v, cnt, rmse_arr);\n\n}\n\nvoid usage(string& doc)\n{\n\tdoc = \"Usage:\\n\";\n\tdoc += \" ./cbmf [-l learningrate] [-L lambda] [-R rank] [-m maxiteration] [-r trainfilename] [-t testfilename] [-o outpath] [-c convint] [-p] [-h] [-v]\\n\";\n\tdoc += \"\\n\";\n\tdoc += \"Options:\\n\";\n\tdoc += \" -l Learning rate. [default: 0.3]\\n\";\n\tdoc += \" -L Regularization parameter. [default: 3]\\n\";\n\tdoc += \" -R Rank. [default: 10]\\n\";\n\tdoc += \" -m Maximum number of iterations. [default: 100]\\n\";\n\tdoc += \" -r Filename of dataset for training. [default: dataset/ml_1m_train.txt]\\n\";\n\tdoc += \" -t Filename of dataset for test. [default: dataset/ml_1m_test.txt]\\n\";\n\tdoc += \" -o Where output files are to be placed. [default: output/]\\n\";\n\tdoc += \" -c Exponent of convergence condition. If RMSE < pow(10, convint) is satisfied, it is regarded as convergence. [default: -5]\\n\";\n\tdoc += \" -p If this option is set, ACBMF is to be performed. Without this option, CBMF is to be done.\\n\";\n\tdoc += \" -h Show help.\\n\";\n\tdoc += \" -v Show version.\\n\";\n\tdoc += \"\\n\";\n\tdoc += \"Examples:\\n\";\n\tdoc += \"Performing CBMF using 'dataset/ml_1m_train.txt' as training dataset and 'dataset/ml_1m_test.txt' as test dataset.\\n\";\n\tdoc += \" ./cbmf -r dataset/ml_1m_train.txt -t dataset/ml_1m_test.txt\\n\";\n\tdoc += \"Performing ACBMF using 'dataset/ml_1m_train.txt' as training dataset and 'dataset/ml_1m_test.txt' as test dataset.\\n\";\n\tdoc += \" ./cbmf -p -r dataset/ml_1m_train.txt -t dataset/ml_1m_test.txt\\n\";\n\tdoc += \"Showing help.\\n\";\n\tdoc += \" ./cbmf -h\\n\";\n\tdoc += \"Showing version.\\n\";\n\tdoc += \" ./cbmf -v\";\n}\n\nvoid version(string& doc)\n{\n\tdoc = \"cbmf v1.0\";\n}\n\n\nint main(int argc, char **argv)\n{\n\tfloat gam = 0.3;\n\tfloat lam = 3;\n\tint R = 10;\n\tint maxCnt = 100;\n\tconst char* train_filename = \"dataset/ml_1m_train.txt\";\n\tconst char* test_filename = \"dataset/ml_1m_test.txt\";\n\tconst char* outpath = \"output/\";\n\tint is_approx = 0;\n\tint conv_int = -5;\n\tint opt;\n\tstring doc = \"\";\n\tusage(doc);\n\tstring vsn = \"\";\n\tversion(vsn);\n\twhile ((opt = getopt(argc, argv, \"l:L:R:m:r:t:o:c:pshv\")) != -1) {\n switch (opt) {\n case 'l': gam=atof(optarg); break;\n case 'L': lam=atof(optarg); break;\n case 'R': R=atoi(optarg); break;\n case 'm': maxCnt=atoi(optarg); break;\n case 'r': train_filename=optarg; break;\n case 't': test_filename=optarg; break;\n case 'o': outpath=optarg; break;\n case 'c': conv_int=atoi(optarg); break;\n case 'p': is_approx=1; break;\n case 'h':\n \tprintf(\"%s\\n\", doc.c_str());\n \treturn 0;\n case 'v':\n \tprintf(\"%s\\n\", vsn.c_str());\n \treturn 0;\n default: \n \tprintf(\"%s\\n\", doc.c_str());\n \treturn 1;\n }\n }\n double conv = pow(10, conv_int);\n\tint folds = 10;\n\n\t\n\tprintf(\"learning rate:%f\\n\", gam);\n\tprintf(\"lambda:%f\\n\", lam);\n\tprintf(\"rank:%d\\n\", R);\n\tprintf(\"maxCnt:%d\\n\", maxCnt);\n\tprintf(\"is_approx:%d\\n\", is_approx);\n\tprintf(\"conv:%f\\n\", conv);\n\n\n\tint* ou_te = NULL;\n\tint* ov_te = NULL;\n\tfloat* y0_te = NULL;\n\tint* ou_tr = NULL;\n\tint* ov_tr = NULL;\n\tfloat* y0_tr = NULL;\n\tint k_te = get_dataset(test_filename,ou_te, ov_te, y0_te);\n\tint k_tr = get_dataset(train_filename,ou_tr, ov_tr, y0_tr);\n\n\tprintf(\"dataset loaded\\n\");\n\n\tint N = maximum_value(ou_tr, k_tr)+1;\n\tint M = maximum_value(ov_tr, k_tr)+1;\n\tint K = k_tr;\n\tprintf(\"N:%d\\n\", N);\n\tprintf(\"M:%d\\n\", M);\n\tprintf(\"K:%d\\n\", K);\n\n\n\tfloat mean = mean_array(y0_tr, k_tr);\n\tfloat std = std_array(y0_tr, k_tr, mean);\n\tprintf(\"mean:%f\\n\", mean);\n\tprintf(\"std:%f\\n\", std);\n\tfor (int i = 0; i < k_tr; ++i)\n\t{\n\t\ty0_tr[i] = (y0_tr[i]-mean)/std;\n\t}\n\n\n\tvector< vector > nbu;\n\tvector< vector > nbv;\n\tvector< vector > nbul;\n\tvector< vector > nbvl;\n\tstd::tie(nbu, nbv, nbul, nbvl) = getNb(ou_tr, ov_tr, N, M, K);\n\n\tprintf(\"got nb\\n\");\n\n\n\tfloat** u;\n\tfloat** v;\n\tint cnt;\n\tfloat* rmse_arr;\n\n\tauto start = std::chrono::system_clock::now();\n\tif (is_approx == 0)\n\t{\n\t\tstd::tie(u, v, cnt, rmse_arr) = cbmf(N, M, ou_tr, ov_tr, nbu, nbv, nbul, nbvl, K, y0_tr, maxCnt, gam, conv, R, lam, ou_te, ov_te, y0_te, k_te, mean, std);\n\t}\n\telse\n\t{\n\t\tstd::tie(u, v, cnt, rmse_arr) = approx_cbmf(N, M, ou_tr, ov_tr, nbu, nbv, nbul, nbvl, K, y0_tr, maxCnt, gam, conv, R, lam, ou_te, ov_te, y0_te, k_te, mean, std);\n\t}\n\tauto end = std::chrono::system_clock::now();\n\n\t\n\tchar gam_char[8];\n\tsprintf(gam_char, \"%.2f\", gam);\n\tchar lam_char[8];\n\tsprintf(lam_char, \"%.5f\", lam);\n\tstd::string filename_base = \"gam=\" + string(gam_char) + \"_lam=\" + string(lam_char) + \"_R=\" + to_string(R) + \"_is_approx=\" + to_string(is_approx);\n\tofstream rmse_f(outpath + filename_base + \"_rmse_approx.txt\");\n\tfor (int i = 0; i < cnt+1; ++i)\n\t{\n\t\tchar rmse_char[16];\n\t\tsprintf(rmse_char, \"%.5f\", rmse_arr[i]);\n\t\trmse_f << rmse_char;\n\t\trmse_f << '\\n';\n\t}\n\trmse_f.close();\n\t\n\n\tprintf(\"main end\\n\");\n\t\n\t \n\treturn 0;\n}", "meta": {"hexsha": "0f7d533446c0871221c5ad8cdd1129a0dd80621d", "size": 20196, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "cbmf.cpp", "max_stars_repo_name": "chnoguchi/cbmf", "max_stars_repo_head_hexsha": "3fceb4605b5f682c42606fb067d49efd85a593a6", "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": "cbmf.cpp", "max_issues_repo_name": "chnoguchi/cbmf", "max_issues_repo_head_hexsha": "3fceb4605b5f682c42606fb067d49efd85a593a6", "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": "cbmf.cpp", "max_forks_repo_name": "chnoguchi/cbmf", "max_forks_repo_head_hexsha": "3fceb4605b5f682c42606fb067d49efd85a593a6", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-12-28T02:50:49.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-09T14:21:40.000Z", "avg_line_length": 20.0955223881, "max_line_length": 355, "alphanum_fraction": 0.5051000198, "num_tokens": 7850, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434978390747, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.49999884243807613}} {"text": "\r\n#include \r\n\r\n#include \r\n\r\nNTL_START_IMPL\r\n\r\n\r\nstatic void ExactDiv(ZZ& qq, const ZZ& a, const ZZ& b)\r\n{\r\n NTL_ZZRegister(q);\r\n NTL_ZZRegister(r);\r\n\r\n DivRem(q, r, a, b);\r\n if (!IsZero(r)) {\r\n cerr << \"a = \" << a << \"\\n\";\r\n cerr << \"b = \" << b << \"\\n\";\r\n LogicError(\"ExactDiv: nonzero remainder\");\r\n }\r\n qq = q;\r\n}\r\n\r\n\r\nstatic void BalDiv(ZZ& q, const ZZ& a, const ZZ& d)\r\n\r\n// rounds a/d to nearest integer, breaking ties\r\n// by rounding towards zero. Assumes d > 0.\r\n\r\n{\r\n NTL_ZZRegister(r);\r\n DivRem(q, r, a, d);\r\n\r\n\r\n add(r, r, r);\r\n\r\n long cmp = compare(r, d);\r\n if (cmp > 0 || (cmp == 0 && q < 0))\r\n add(q, q, 1);\r\n}\r\n\r\n\r\n\r\nstatic void MulAddDiv(ZZ& c, const ZZ& c1, const ZZ& c2, \r\n const ZZ& x, const ZZ& y, const ZZ& z)\r\n\r\n// c = (x*c1 + y*c2)/z\r\n\r\n{\r\n NTL_ZZRegister(t1);\r\n NTL_ZZRegister(t2);\r\n\r\n mul(t1, x, c1);\r\n mul(t2, y, c2);\r\n add(t1, t1, t2);\r\n ExactDiv(c, t1, z);\r\n}\r\n\r\n\r\nstatic void MulSubDiv(ZZ& c, const ZZ& c1, const ZZ& c2, \r\n const ZZ& x, const ZZ& y, const ZZ& z)\r\n\r\n// c = (x*c1 - y*c2)/z\r\n\r\n{\r\n NTL_ZZRegister(t1);\r\n NTL_ZZRegister(t2);\r\n\r\n mul(t1, x, c1);\r\n mul(t2, y, c2);\r\n sub(t1, t1, t2);\r\n ExactDiv(c, t1, z);\r\n}\r\n \r\n\r\n\r\n\r\n\r\n#if 0\r\n\r\nstatic void MulSubDiv(vec_ZZ& c, const vec_ZZ& c1, const vec_ZZ& c2,\r\n const ZZ& x, const ZZ& y, const ZZ& z)\r\n\r\n// c = (x*c1 + y*c2)/z\r\n\r\n{\r\n long n = c1.length();\r\n if (c2.length() != n) LogicError(\"MulSubDiv: length mismatch\");\r\n c.SetLength(n);\r\n\r\n long i;\r\n for (i = 1; i <= n; i++) \r\n MulSubDiv(c(i), c1(i), c2(i), x, y, z);\r\n}\r\n\r\n#endif\r\n\r\nstatic void RowTransform(vec_ZZ& c1, vec_ZZ& c2,\r\n const ZZ& x, const ZZ& y, const ZZ& u, const ZZ& v)\r\n\r\n// (c1, c2) = (x*c1 + y*c2, u*c1 + v*c2)\r\n\r\n{\r\n long n = c1.length();\r\n if (c2.length() != n) LogicError(\"MulSubDiv: length mismatch\");\r\n NTL_ZZRegister(t1);\r\n NTL_ZZRegister(t2);\r\n NTL_ZZRegister(t3);\r\n NTL_ZZRegister(t4);\r\n\r\n long i;\r\n for (i = 1; i <= n; i++) {\r\n mul(t1, x, c1(i));\r\n mul(t2, y, c2(i));\r\n add(t1, t1, t2);\r\n\r\n mul(t3, u, c1(i));\r\n mul(t4, v, c2(i));\r\n add(t3, t3, t4);\r\n\r\n c1(i) = t1;\r\n c2(i) = t3;\r\n }\r\n}\r\n\r\nstatic void RowTransform(ZZ& c1, ZZ& c2,\r\n const ZZ& x, const ZZ& y, const ZZ& u, const ZZ& v)\r\n\r\n// (c1, c2) = (x*c1 + y*c2, u*c1 + v*c2)\r\n\r\n{\r\n NTL_ZZRegister(t1);\r\n NTL_ZZRegister(t2);\r\n NTL_ZZRegister(t3);\r\n NTL_ZZRegister(t4);\r\n\r\n mul(t1, x, c1);\r\n mul(t2, y, c2);\r\n add(t1, t1, t2);\r\n\r\n mul(t3, u, c1);\r\n mul(t4, v, c2);\r\n add(t3, t3, t4);\r\n\r\n c1 = t1;\r\n c2 = t3;\r\n}\r\n\r\n\r\n\r\nstatic void MulSubFrom(vec_ZZ& c, const vec_ZZ& c2, const ZZ& x)\r\n\r\n// c = c - x*c2\r\n\r\n{\r\n long n = c.length();\r\n if (c2.length() != n) LogicError(\"MulSubFrom: length mismatch\");\r\n\r\n long i;\r\n for (i = 1; i <= n; i++)\r\n MulSubFrom(c(i), c2(i), x);\r\n}\r\n\r\nstatic void MulSubFrom(vec_ZZ& c, const vec_ZZ& c2, long x)\r\n\r\n// c = c - x*c2\r\n\r\n{\r\n long n = c.length();\r\n if (c2.length() != n) LogicError(\"MulSubFrom: length mismatch\");\r\n\r\n long i;\r\n for (i = 1; i <= n; i++)\r\n MulSubFrom(c(i), c2(i), x);\r\n}\r\n\r\n\r\n \r\n \r\n \r\nstatic long SwapTest(const ZZ& d0, const ZZ& d1, const ZZ& d2, const ZZ& lam,\r\n long a, long b)\r\n\r\n// test if a*d1^2 > b*(d0*d2 + lam^2)\r\n\r\n{\r\n NTL_ZZRegister(t1);\r\n NTL_ZZRegister(t2);\r\n\r\n mul(t1, d0, d2);\r\n sqr(t2, lam);\r\n add(t1, t1, t2);\r\n mul(t1, t1, b);\r\n\r\n sqr(t2, d1);\r\n mul(t2, t2, a);\r\n\r\n return t2 > t1;\r\n}\r\n\r\n\r\n\r\n\r\n\r\n\r\nstatic\r\nvoid reduce(long k, long l, \r\n mat_ZZ& B, vec_long& P, vec_ZZ& D, \r\n vec_vec_ZZ& lam, mat_ZZ* U)\r\n{\r\n NTL_ZZRegister(t1);\r\n NTL_ZZRegister(r);\r\n\r\n if (P(l) == 0) return;\r\n add(t1, lam(k)(P(l)), lam(k)(P(l)));\r\n abs(t1, t1);\r\n if (t1 <= D[P(l)]) return;\r\n\r\n long j;\r\n long rr, small_r;\r\n\r\n BalDiv(r, lam(k)(P(l)), D[P(l)]);\r\n\r\n if (r.WideSinglePrecision()) {\r\n small_r = 1;\r\n rr = to_long(r);\r\n }\r\n else {\r\n small_r = 0;\r\n }\r\n \r\n if (small_r) {\r\n MulSubFrom(B(k), B(l), rr);\r\n\r\n if (U) MulSubFrom((*U)(k), (*U)(l), rr);\r\n\r\n for (j = 1; j <= l-1; j++)\r\n if (P(j) != 0)\r\n MulSubFrom(lam(k)(P(j)), lam(l)(P(j)), rr);\r\n MulSubFrom(lam(k)(P(l)), D[P(l)], rr);\r\n }\r\n else {\r\n MulSubFrom(B(k), B(l), r);\r\n\r\n if (U) MulSubFrom((*U)(k), (*U)(l), r);\r\n\r\n for (j = 1; j <= l-1; j++)\r\n if (P(j) != 0)\r\n MulSubFrom(lam(k)(P(j)), lam(l)(P(j)), r);\r\n MulSubFrom(lam(k)(P(l)), D[P(l)], r);\r\n }\r\n\r\n\r\n}\r\n\r\n\r\nstatic\r\nlong swap(long k, mat_ZZ& B, vec_long& P, vec_ZZ& D, \r\n vec_vec_ZZ& lam, mat_ZZ* U, long m, long verbose)\r\n\r\n// swaps vectors k-1 and k; assumes P(k-1) != 0\r\n// returns 1 if vector k-1 need to be reduced after the swap...\r\n// this only occurs in 'case 2' when there are linear dependencies\r\n\r\n{\r\n long i, j;\r\n NTL_ZZRegister(t1);\r\n NTL_ZZRegister(t2);\r\n NTL_ZZRegister(t3);\r\n NTL_ZZRegister(e);\r\n NTL_ZZRegister(x);\r\n NTL_ZZRegister(y);\r\n\r\n\r\n if (P(k) != 0) {\r\n if (verbose) cerr << \"swap case 1: \" << k << \"\\n\";\r\n\r\n swap(B(k-1), B(k));\r\n if (U) swap((*U)(k-1), (*U)(k));\r\n \r\n for (j = 1; j <= k-2; j++)\r\n if (P(j) != 0)\r\n swap(lam(k-1)(P(j)), lam(k)(P(j)));\r\n\r\n for (i = k+1; i <= m; i++) {\r\n MulAddDiv(t1, lam(i)(P(k)-1), lam(i)(P(k)), \r\n lam(k)(P(k)-1), D[P(k)-2], D[P(k)-1]); \r\n MulSubDiv(t2, lam(i)(P(k)-1), lam(i)(P(k)), \r\n D[P(k)], lam(k)(P(k)-1), D[P(k)-1]);\r\n lam(i)(P(k)-1) = t1;\r\n lam(i)(P(k)) = t2;\r\n }\r\n\r\n MulAddDiv(D[P(k)-1], D[P(k)], lam(k)(P(k)-1),\r\n D[P(k)-2], lam(k)(P(k)-1), D[P(k)-1]);\r\n\r\n return 0;\r\n }\r\n else if (!IsZero(lam(k)(P(k-1)))) {\r\n if (verbose) cerr << \"swap case 2: \" << k << \"\\n\";\r\n XGCD(e, x, y, lam(k)(P(k-1)), D[P(k-1)]);\r\n\r\n ExactDiv(t1, lam(k)(P(k-1)), e);\r\n ExactDiv(t2, D[P(k-1)], e);\r\n\r\n t3 = t2;\r\n negate(t2, t2);\r\n RowTransform(B(k-1), B(k), t1, t2, y, x);\r\n if (U) RowTransform((*U)(k-1), (*U)(k), t1, t2, y, x);\r\n for (j = 1; j <= k-2; j++)\r\n if (P(j) != 0)\r\n RowTransform(lam(k-1)(P(j)), lam(k)(P(j)), t1, t2, y, x);\r\n\r\n sqr(t2, t2);\r\n ExactDiv(D[P(k-1)], D[P(k-1)], t2);\r\n\r\n for (i = k+1; i <= m; i++)\r\n if (P(i) != 0) {\r\n ExactDiv(D[P(i)], D[P(i)], t2);\r\n for (j = i+1; j <= m; j++) {\r\n ExactDiv(lam(j)(P(i)), lam(j)(P(i)), t2);\r\n }\r\n }\r\n\r\n for (i = k+1; i <= m; i++) {\r\n ExactDiv(lam(i)(P(k-1)), lam(i)(P(k-1)), t3);\r\n }\r\n\r\n swap(P(k-1), P(k));\r\n\r\n return 1;\r\n }\r\n else {\r\n if (verbose) cerr << \"swap case 3: \" << k << \"\\n\";\r\n\r\n swap(B(k-1), B(k));\r\n if (U) swap((*U)(k-1), (*U)(k));\r\n \r\n for (j = 1; j <= k-2; j++)\r\n if (P(j) != 0)\r\n swap(lam(k-1)(P(j)), lam(k)(P(j)));\r\n\r\n swap(P(k-1), P(k));\r\n\r\n return 0;\r\n }\r\n}\r\n\r\n \r\n\r\n\r\nstatic\r\nvoid IncrementalGS(mat_ZZ& B, vec_long& P, vec_ZZ& D, vec_vec_ZZ& lam, \r\n long& s, long k)\r\n{\r\n long n = B.NumCols();\r\n long m = B.NumRows();\r\n\r\n NTL_ZZRegister(u);\r\n NTL_ZZRegister(t1);\r\n NTL_ZZRegister(t2);\r\n\r\n long i, j;\r\n\r\n for (j = 1; j <= k-1; j++) {\r\n long posj = P(j);\r\n if (posj == 0) continue;\r\n\r\n InnerProduct(u, B(k), B(j));\r\n for (i = 1; i <= posj-1; i++) {\r\n mul(t1, D[i], u);\r\n mul(t2, lam(k)(i), lam(j)(i));\r\n sub(t1, t1, t2);\r\n div(t1, t1, D[i-1]);\r\n u = t1;\r\n }\r\n\r\n lam(k)(posj) = u;\r\n }\r\n\r\n InnerProduct(u, B(k), B(k));\r\n for (i = 1; i <= s; i++) {\r\n mul(t1, D[i], u);\r\n mul(t2, lam(k)(i), lam(k)(i));\r\n sub(t1, t1, t2);\r\n div(t1, t1, D[i-1]);\r\n u = t1;\r\n }\r\n\r\n if (u == 0) {\r\n P(k) = 0;\r\n }\r\n else {\r\n s++;\r\n P(k) = s;\r\n D[s] = u;\r\n }\r\n}\r\n\r\n\r\nstatic\r\nlong LLL(vec_ZZ& D, mat_ZZ& B, mat_ZZ* U, long a, long b, long verbose)\r\n{\r\n long m = B.NumRows();\r\n long n = B.NumCols();\r\n\r\n long force_reduce = 1;\r\n\r\n vec_long P;\r\n P.SetLength(m);\r\n\r\n D.SetLength(m+1);\r\n D[0] = 1;\r\n\r\n vec_vec_ZZ lam;\r\n\r\n lam.SetLength(m);\r\n\r\n long j;\r\n for (j = 1; j <= m; j++)\r\n lam(j).SetLength(m);\r\n\r\n if (U) ident(*U, m);\r\n\r\n long s = 0;\r\n\r\n long k = 1;\r\n long max_k = 0;\r\n\r\n\r\n while (k <= m) {\r\n if (k > max_k) {\r\n IncrementalGS(B, P, D, lam, s, k);\r\n max_k = k;\r\n }\r\n\r\n if (k == 1) {\r\n force_reduce = 1; \r\n k++;\r\n continue;\r\n }\r\n\r\n if (force_reduce)\r\n for (j = k-1; j >= 1; j--)\r\n reduce(k, j, B, P, D, lam, U);\r\n\r\n if (P(k-1) != 0 && \r\n (P(k) == 0 || \r\n SwapTest(D[P(k)], D[P(k)-1], D[P(k)-2], lam(k)(P(k)-1), a, b))) {\r\n force_reduce = swap(k, B, P, D, lam, U, max_k, verbose);\r\n k--;\r\n }\r\n else {\r\n force_reduce = 1;\r\n k++;\r\n }\r\n }\r\n\r\n D.SetLength(s+1);\r\n return s;\r\n}\r\n\r\n\r\n\r\nstatic\r\nlong image(ZZ& det, mat_ZZ& B, mat_ZZ* U, long verbose)\r\n{\r\n long m = B.NumRows();\r\n long n = B.NumCols();\r\n\r\n long force_reduce = 1;\r\n\r\n vec_long P;\r\n P.SetLength(m);\r\n\r\n vec_ZZ D;\r\n D.SetLength(m+1);\r\n D[0] = 1;\r\n\r\n vec_vec_ZZ lam;\r\n\r\n lam.SetLength(m);\r\n\r\n long j;\r\n for (j = 1; j <= m; j++)\r\n lam(j).SetLength(m);\r\n\r\n if (U) ident(*U, m);\r\n\r\n long s = 0;\r\n\r\n long k = 1;\r\n long max_k = 0;\r\n\r\n\r\n while (k <= m) {\r\n if (k > max_k) {\r\n IncrementalGS(B, P, D, lam, s, k);\r\n max_k = k;\r\n }\r\n\r\n if (k == 1) {\r\n force_reduce = 1; \r\n k++;\r\n continue;\r\n }\r\n\r\n if (force_reduce)\r\n for (j = k-1; j >= 1; j--) \r\n reduce(k, j, B, P, D, lam, U);\r\n\r\n if (P(k-1) != 0 && P(k) == 0) {\r\n force_reduce = swap(k, B, P, D, lam, U, max_k, verbose);\r\n k--;\r\n }\r\n else {\r\n force_reduce = 1;\r\n k++;\r\n }\r\n }\r\n\r\n det = D[s];\r\n return s;\r\n}\r\n\r\nlong LLL(ZZ& det, mat_ZZ& B, mat_ZZ& U, long verbose)\r\n{\r\n vec_ZZ D;\r\n long s;\r\n s = LLL(D, B, &U, 3, 4, verbose);\r\n det = D[s];\r\n return s;\r\n}\r\n\r\nlong LLL(ZZ& det, mat_ZZ& B, long verbose)\r\n{\r\n vec_ZZ D;\r\n long s;\r\n s = LLL(D, B, 0, 3, 4, verbose);\r\n det = D[s];\r\n return s;\r\n}\r\n\r\nlong LLL(ZZ& det, mat_ZZ& B, mat_ZZ& U, long a, long b, long verbose)\r\n{\r\n if (a <= 0 || b <= 0 || a > b || b/4 >= a) LogicError(\"LLL: bad args\");\r\n\r\n vec_ZZ D;\r\n long s;\r\n s = LLL(D, B, &U, a, b, verbose);\r\n det = D[s];\r\n return s;\r\n}\r\n\r\nlong LLL(ZZ& det, mat_ZZ& B, long a, long b, long verbose)\r\n{\r\n if (a <= 0 || b <= 0 || a > b || b/4 >= a) LogicError(\"LLL: bad args\");\r\n\r\n vec_ZZ D;\r\n long s;\r\n s = LLL(D, B, 0, a, b, verbose);\r\n det = D[s];\r\n return s;\r\n}\r\n\r\n\r\nlong LLL_plus(vec_ZZ& D_out, mat_ZZ& B, mat_ZZ& U, long verbose)\r\n{\r\n vec_ZZ D;\r\n long s;\r\n s = LLL(D, B, &U, 3, 4, verbose);\r\n D_out = D;\r\n return s;\r\n}\r\n\r\nlong LLL_plus(vec_ZZ& D_out, mat_ZZ& B, long verbose)\r\n{\r\n vec_ZZ D;\r\n long s;\r\n s = LLL(D, B, 0, 3, 4, verbose);\r\n D_out = D;\r\n return s;\r\n}\r\n\r\nlong LLL_plus(vec_ZZ& D_out, mat_ZZ& B, mat_ZZ& U, long a, long b, long verbose)\r\n{\r\n if (a <= 0 || b <= 0 || a > b || b/4 >= a) LogicError(\"LLL_plus: bad args\");\r\n\r\n vec_ZZ D;\r\n long s;\r\n s = LLL(D, B, &U, a, b, verbose);\r\n D_out = D;\r\n return s;\r\n}\r\n\r\nlong LLL_plus(vec_ZZ& D_out, mat_ZZ& B, long a, long b, long verbose)\r\n{\r\n if (a <= 0 || b <= 0 || a > b || b/4 >= a) LogicError(\"LLL_plus: bad args\");\r\n\r\n vec_ZZ D;\r\n long s;\r\n s = LLL(D, B, 0, a, b, verbose);\r\n D_out = D;\r\n return s;\r\n}\r\n\r\n\r\nlong image(ZZ& det, mat_ZZ& B, mat_ZZ& U, long verbose)\r\n{\r\n return image(det, B, &U, verbose);\r\n}\r\n\r\nlong image(ZZ& det, mat_ZZ& B, long verbose)\r\n{\r\n return image(det, B, 0, verbose);\r\n}\r\n\r\nlong LatticeSolve(vec_ZZ& x, const mat_ZZ& A, const vec_ZZ& y, long reduce)\r\n{\r\n long n = A.NumRows();\r\n long m = A.NumCols();\r\n\r\n if (y.length() != m)\r\n LogicError(\"LatticeSolve: dimension mismatch\");\r\n\r\n if (reduce < 0 || reduce > 2)\r\n LogicError(\"LatticeSolve: bad reduce parameter\");\r\n\r\n if (IsZero(y)) {\r\n x.SetLength(n);\r\n clear(x);\r\n return 1;\r\n }\r\n\r\n mat_ZZ A1, U1;\r\n ZZ det2;\r\n long im_rank, ker_rank;\r\n\r\n A1 = A;\r\n\r\n im_rank = image(det2, A1, U1);\r\n ker_rank = n - im_rank;\r\n\r\n mat_ZZ A2, U2;\r\n long new_rank;\r\n long i;\r\n\r\n A2.SetDims(im_rank + 1, m);\r\n for (i = 1; i <= im_rank; i++)\r\n A2(i) = A1(ker_rank + i);\r\n\r\n A2(im_rank + 1) = y;\r\n\r\n new_rank = image(det2, A2, U2);\r\n\r\n if (new_rank != im_rank || \r\n (U2(1)(im_rank+1) != 1 && U2(1)(im_rank+1) != -1))\r\n return 0;\r\n\r\n vec_ZZ x1;\r\n x1.SetLength(im_rank);\r\n\r\n for (i = 1; i <= im_rank; i++)\r\n x1(i) = U2(1)(i);\r\n\r\n if (U2(1)(im_rank+1) == 1)\r\n negate(x1, x1);\r\n\r\n vec_ZZ x2, tmp;\r\n x2.SetLength(n);\r\n clear(x2);\r\n tmp.SetLength(n);\r\n\r\n for (i = 1; i <= im_rank; i++) {\r\n mul(tmp, U1(ker_rank+i), x1(i));\r\n add(x2, x2, tmp);\r\n }\r\n\r\n if (reduce == 0) {\r\n x = x2;\r\n return 1;\r\n }\r\n else if (reduce == 1) {\r\n U1.SetDims(ker_rank+1, n);\r\n U1(ker_rank+1) = x2;\r\n image(det2, U1);\r\n\r\n x = U1(ker_rank + 1);\r\n return 1;\r\n }\r\n else if (reduce == 2) {\r\n U1.SetDims(ker_rank, n);\r\n LLL(det2, U1);\r\n U1.SetDims(ker_rank+1, n);\r\n U1(ker_rank+1) = x2;\r\n image(det2, U1);\r\n\r\n x = U1(ker_rank + 1);\r\n return 1;\r\n }\r\n\r\n return 0;\r\n} \r\n\r\n\r\n\r\nNTL_END_IMPL\r\n", "meta": {"hexsha": "d511deefd1d4b3b95b0e526fc98d83c2d102f668", "size": 13793, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "WinNTL-8_1_2/src/LLL.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/LLL.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/LLL.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.5091937765, "max_line_length": 81, "alphanum_fraction": 0.4410208077, "num_tokens": 5039, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434978390747, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.49999884243807613}} {"text": "#include \"generator.hpp\"\n\n#include \n#include \n#include \n\n#include \n\nnamespace crossbow {\n\nCrossbowRandomGenerator::CrossbowRandomGenerator (unsigned int seed) {\n\n\tthis->seed = seed;\n\tthis->rng = new rng_t(seed);\n}\n\nfloat CrossbowRandomGenerator::nextafter (const float value) {\n\n\treturn boost::math::nextafter(value, std::numeric_limits::max());\n}\n\nvoid CrossbowRandomGenerator::randomUniformFill (float *buffer, const int count, const float start, const float end) {\n\n\tif (buffer == NULL) {\n\t\tfprintf(stderr, \"error: buffer to fill must not be null\\n\");\n\t\texit (1);\n\t}\n\n\tif (count < 0) {\n\t\tfprintf(stderr, \"error: number of buffer elements to fill must be greater or equal to 0\\n\");\n\t\texit (1);\n\t}\n\n\tif (start > end) {\n\t\tfprintf(stderr, \"error: invalid uniform random distribution specification\\n\");\n\t\texit (1);\n\t}\n\n\tboost::uniform_real dist (start, nextafter (end));\n\tboost::variate_generator > variate_generator (this->rng, dist);\n\n\tfor (int i = 0; i < count; ++i)\n\t\tbuffer [i] = variate_generator ();\n\n\treturn;\n}\n\nvoid CrossbowRandomGenerator::randomGaussianFill (float *buffer, const int count, const float mean, const float std, const int truncate) {\n\n\tif (buffer == NULL) {\n\t\tfprintf(stderr, \"error: buffer to fill must not be null\\n\");\n\t\texit (1);\n\t}\n\n\tif (count < 0) {\n\t\tfprintf(stderr, \"error: number of buffer elements to fill must be greater or equal to 0\\n\");\n\t\texit (1);\n\t}\n\n\tif (std <= 0) {\n\t\tfprintf(stderr, \"error: invalid normal distribution specification\\n\");\n\t\texit (1);\n\t}\n\n\tboost::normal_distribution dist (mean, std);\n\tboost::variate_generator > variate_generator (this->rng, dist);\n\t\n\t/* float checksum = 0; */\n\n\tif (truncate) {\n\n\t\t/*\n\t\t * Added on 14 Apr 2018: Hard-coded truncated version:\n\t\t *\n\t\t * Values whose magnitude is more than 2 standard deviations\n\t\t * from the mean are dropped and re-picked.\n\t\t */\n\t\tfloat min = mean - (2 * std);\n\t\tfloat max = mean + (2 * std);\n\t\tint maxiterations = 100;\n\t\n\t\tfloat sample;\n\t\tint correct = 0;\n\t\tfor (int i = 0; i < count; ++i) {\n\t\t\tfor (int j = 0; j < maxiterations; ++j) {\n\t\t\t\tsample = variate_generator ();\n\t\t\t\tif ((sample > min) && (sample < max)) {\n\t\t\t\t\tcorrect ++;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tbuffer [i] = sample;\n\t\t\t/* checksum += buffer [i]; */\n\t\t}\n\t\tif (correct < count)\n\t\t\tfprintf(stderr, \"warning: only %d out of %d values truncated\\n\", correct, count);\n\t}\n\telse {\n\t\tfor (int i = 0; i < count; ++i) {\n\t\t\tbuffer [i] = variate_generator ();\n\t\t\t/* checksum += buffer [i]; */\n\t\t}\n\t}\n\t/*\n\t * fprintf(stdout, \"[DBG] checksum is %.5f\\n\", checksum);\n\t * fflush (stdout);\n\t */\n\n\treturn;\n}\n\nvoid CrossbowRandomGenerator::dump () {\n\n\tfprintf(stdout, \"CrossbowRandom (%du)\\n\", seed);\n\tfflush (stdout);\n}\n\n} /* namespace crossbow */\n", "meta": {"hexsha": "2f41febaaa7e79e2318a4a0d8ecf26f27de5f936", "size": 2962, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "clib-multigpu/random/generator.cpp", "max_stars_repo_name": "lsds/Crossbow", "max_stars_repo_head_hexsha": "d4441b35315f9f7d48293fe81faaf21e1ca48002", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 50.0, "max_stars_repo_stars_event_min_datetime": "2019-01-09T14:30:41.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T11:42:51.000Z", "max_issues_repo_path": "clib-multigpu/random/generator.cpp", "max_issues_repo_name": "lsds/Crossbow", "max_issues_repo_head_hexsha": "d4441b35315f9f7d48293fe81faaf21e1ca48002", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-01-18T07:31:39.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-14T21:16:53.000Z", "max_forks_repo_path": "clib-multigpu/random/generator.cpp", "max_forks_repo_name": "lsds/Crossbow", "max_forks_repo_head_hexsha": "d4441b35315f9f7d48293fe81faaf21e1ca48002", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2019-03-20T14:56:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T06:13:09.000Z", "avg_line_length": 24.8907563025, "max_line_length": 138, "alphanum_fraction": 0.6576637407, "num_tokens": 812, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434978390747, "lm_q2_score": 0.6477982043529715, "lm_q1q2_score": 0.4999988319416692}} {"text": "#include \"third_party/frc971/control_loops/paths/path.h\"\n#include \n\n#define _USE_MATH_DEFINES\n#include \n\n#include \"muan/logging/logger.h\"\n\nnamespace frc971 {\nnamespace control_loops {\nnamespace paths {\n\nEigen::Vector2d Projection(Eigen::Vector2d a, Eigen::Vector2d direction) {\n return a.dot(direction) * direction.dot(direction) * direction;\n}\n\nPosition FromMagDirection(double magnitude, double direction) {\n return magnitude * (Position() << ::std::cos(direction), ::std::sin(direction)).finished();\n}\n\nPose::Pose(Eigen::Vector3d values) : values_(values) {}\n\nPose::Pose(Position pos, double theta) {\n values_.block<2, 1>(0, 0) = pos;\n values_(2) = remainder(theta, 2 * M_PI);\n}\n\nPose Pose::operator+(const Pose &other) const {\n Eigen::Vector3d new_values = values_ + other.values_;\n\n // Wrap the heading into [-pi, pi]\n new_values(2) = remainder(new_values(2), 2 * M_PI);\n\n return Pose(new_values);\n}\n\nPose Pose::TranslateBy(const Position &delta) const {\n Eigen::Vector3d new_values = values_;\n new_values.block<2, 1>(0, 0) += delta;\n return Pose(new_values);\n}\n\nPose Pose::RotateBy(double theta) const {\n Eigen::Vector3d new_values = values_;\n new_values.block<2, 1>(0, 0) = Eigen::Rotation2D(theta) * new_values.block<2, 1>(0, 0);\n\n // Wrap the heading into [-pi, pi]\n new_values(2) = remainder(new_values(2) + theta, 2 * M_PI);\n\n return Pose(new_values);\n}\n\nPose Pose::operator-(const Pose &other) const {\n Eigen::Vector3d new_values = values_ - other.values_;\n\n // Wrap the heading into [-pi, pi]\n new_values(2) = remainder(new_values(2), 2 * M_PI);\n return Pose(new_values);\n}\n\nPose Pose::Compose(const Pose &other) const { return other.RotateBy(heading()).TranslateBy(translational()); }\n\nHermitePath::HermitePath(Pose initial, Pose final,\n double initial_velocity, double final_velocity, bool backwards,\n double extra_distance_initial, double extra_distance_final,\n double initial_angular_velocity,\n double final_angular_velocity)\n : HermitePath(initial.translational(),\n FromMagDirection(1, initial.heading()),\n final.translational(),\n FromMagDirection(1, final.heading()),\n initial_velocity, final_velocity, backwards,\n extra_distance_initial, extra_distance_final,\n initial_angular_velocity, final_angular_velocity) {}\n\nHermitePath::HermitePath(Position initial_position, Eigen::Vector2d initial_tangent,\n Position final_position, Eigen::Vector2d final_tangent,\n double initial_velocity, double final_velocity, bool backwards,\n double extra_distance_initial, double extra_distance_final,\n double initial_angular_velocity,\n double final_angular_velocity) {\n backwards_ = backwards;\n\n Eigen::Vector2d initial_derivative_basis;\n Eigen::Vector2d final_derivative_basis;\n double initial_deriv_magnitude;\n double final_deriv_magnitude;\n\n {\n Eigen::Vector2d distance = final_position - initial_position;\n // How far to the side are we driving, relative to initial state?\n Eigen::Vector2d sideways = distance - Projection(distance, initial_tangent);\n // How far to the front is the sideways vector, relative to final state?\n double forwards2 = sideways.dot(final_tangent);\n if (backwards) {\n forwards2 *= -1;\n }\n // Rough estimate of the curvature, this should be approximately\n // correct as long as the curvature doesn't have excessively large changes.\n double approx_curve = (sideways.norm() * 2 - forwards2) / distance.norm();\n // Standard hermite spline uses tangent * |distance|, but initial velocity\n // should be taken into account as well, although only sigmificantly if\n // distance is short and initial velocity is high. This formula was found\n // experimentally.\n initial_deriv_magnitude = distance.norm() + extra_distance_initial * 5.0 +\n initial_velocity * initial_velocity * 0.5 * approx_curve * approx_curve;\n final_deriv_magnitude = distance.norm() + extra_distance_final * 5.0 +\n final_velocity * final_velocity * 0.5 * approx_curve * approx_curve;\n }\n\n initial_derivative_basis = initial_tangent * initial_deriv_magnitude;\n final_derivative_basis = final_tangent * final_deriv_magnitude;\n\n if (backwards_) {\n initial_derivative_basis *= -1;\n final_derivative_basis *= -1;\n }\n\n Eigen::Vector2d initial_acceleration = Eigen::Vector2d::Zero();\n if (initial_velocity > 0.01 || initial_velocity < -0.01) {\n initial_acceleration =\n (Eigen::Vector2d() << -initial_tangent(1), initial_tangent(0)).finished() *\n initial_deriv_magnitude * final_deriv_magnitude *\n initial_angular_velocity / initial_velocity;\n } else if (initial_angular_velocity > 0.01 || initial_angular_velocity < -0.01) {\n LOG(WARNING, \"Initial velocity required if initial angular velocity present\"\n \" (v_0 = %f, omega_0 = %f, cutoff = 0.01)\",\n initial_velocity, initial_angular_velocity);\n }\n\n Eigen::Vector2d final_acceleration = Eigen::Vector2d::Zero();\n if (final_velocity > 0.01 || final_velocity < -0.01) {\n final_acceleration =\n (Eigen::Vector2d() << -final_tangent(1), final_tangent(0)).finished() *\n final_deriv_magnitude * final_deriv_magnitude *\n final_angular_velocity / final_velocity;\n } else if (final_angular_velocity > 0.01 || final_angular_velocity < -0.01) {\n LOG(WARNING, \"Final velocity required if final angular velocity present\"\n \" (v_f = %f, omega_f = %f, cutoff = 0.01)\",\n final_velocity, final_angular_velocity);\n }\n\n coefficients_ = Eigen::Matrix::Zero();\n coefficients_.block<2, 1>(0, 0) = initial_position;\n coefficients_.block<2, 1>(0, 1) = initial_derivative_basis;\n coefficients_.block<2, 1>(0, 2) = 0.5 * initial_acceleration;\n coefficients_.block<2, 1>(0, 3) =\n -10 * initial_position - 6 * initial_derivative_basis +\n -1.5 * initial_acceleration + 0.5 * final_acceleration +\n -4 * final_derivative_basis + 10 * final_position;\n coefficients_.block<2, 1>(0, 4) =\n 15 * initial_position + 8 * initial_derivative_basis +\n 1.5 * initial_acceleration - 1 * final_acceleration +\n 7 * final_derivative_basis - 15 * final_position;\n coefficients_.block<2, 1>(0, 5) =\n -6 * initial_position - 3 * initial_derivative_basis +\n -0.5 * initial_acceleration + 0.5 * final_acceleration +\n -3 * final_derivative_basis + 6 * final_position;\n\n for (int i = 0; i < 6; i++) {\n coefficients_.block<2, 1>(2, i) = coefficients_.block<2, 1>(0, i) * i;\n }\n\n initial_heading_ = remainder(::std::atan2(initial_tangent(1), initial_tangent(0)), 2 * M_PI);\n}\n\nvoid HermitePath::Populate(double s_min, double s_max, Pose *pose_arr, size_t arr_len) const {\n Eigen::Matrix s_polynomial_bases;\n double step = (s_max - s_min) / (arr_len - 1);\n for (size_t i = 0; i < arr_len; i++) {\n double s = s_min + i * step;\n s_polynomial_bases << 1.0, s, s * s, s * s * s, s * s * s * s, s * s * s * s * s;\n\n Eigen::Vector4d combined = coefficients_ * s_polynomial_bases;\n\n double theta;\n if (s == 0) {\n // When s is _exactly_ zero, we can't get the heading directly from\n // the derivative (because it collapses to zero)! Let's use the cached\n // value instead.\n theta = initial_heading_;\n } else {\n theta = ::std::atan2(combined(3), combined(2));\n if (backwards_) {\n if (theta > 0) {\n theta -= M_PI;\n } else {\n theta += M_PI;\n }\n }\n }\n\n pose_arr[i] = Pose(combined.block<2, 1>(0, 0), theta);\n }\n}\n\n} // namespace paths\n} // namespace control_loops\n} // namespace frc971\n", "meta": {"hexsha": "dd91c963d33f365d5969328e46dda4ede086733c", "size": 7951, "ext": "cc", "lang": "C++", "max_stars_repo_path": "third_party/frc971/control_loops/paths/path.cc", "max_stars_repo_name": "hansonl02/frc-robot-code", "max_stars_repo_head_hexsha": "4b120c917a7709df9f010c9089a87c320bab3a16", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 61.0, "max_stars_repo_stars_event_min_datetime": "2017-01-22T04:38:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-07T00:04:37.000Z", "max_issues_repo_path": "third_party/frc971/control_loops/paths/path.cc", "max_issues_repo_name": "hansonl02/frc-robot-code", "max_issues_repo_head_hexsha": "4b120c917a7709df9f010c9089a87c320bab3a16", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2018-06-28T05:34:57.000Z", "max_issues_repo_issues_event_max_datetime": "2019-01-16T15:46:22.000Z", "max_forks_repo_path": "third_party/frc971/control_loops/paths/path.cc", "max_forks_repo_name": "hansonl02/frc-robot-code", "max_forks_repo_head_hexsha": "4b120c917a7709df9f010c9089a87c320bab3a16", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 17.0, "max_forks_repo_forks_event_min_datetime": "2017-05-12T15:32:03.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-09T12:49:38.000Z", "avg_line_length": 39.755, "max_line_length": 110, "alphanum_fraction": 0.6649478053, "num_tokens": 2037, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673269042768, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.499984820924629}} {"text": "/* ---------------------------------------------------------------------\n *\n * Copyright (C) 2000 - 2020 by the deal.II authors\n *\n * This file is part of the deal.II library.\n *\n * The deal.II library is free software; you can use it, redistribute\n * it, and/or modify it under the terms of the GNU Lesser General\n * Public License as published by the Free Software Foundation; either\n * version 2.1 of the License, or (at your option) any later version.\n * The full text of the license can be found in the file LICENSE.md at\n * the top level directory of deal.II.\n *\n * ---------------------------------------------------------------------\n\n *\n * Author: Wolfgang Bangerth, University of Heidelberg, 2000\n */\n\n\n\n#include \n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \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\nusing namespace dealii;\n\n\n\ntemplate \nclass Step6\n{\npublic:\n Step6();\n\n void\n run();\n\nprivate:\n void\n setup_system();\n void\n assemble_system();\n void\n solve();\n void\n refine_grid();\n void\n output_results(const unsigned int cycle) const;\n\n Triangulation triangulation;\n\n FE_Q fe_velocity;\n FE_DGP fe_pressure;\n FESystem fe;\n\n FEValuesExtractors::Vector velocity;\n FEValuesExtractors::Scalar pressure;\n\n DoFHandler dof_handler;\n\n AffineConstraints constraints;\n\n SparseMatrix system_matrix;\n SparsityPattern sparsity_pattern;\n\n Vector solution;\n Vector system_rhs;\n};\n\n\n\ntemplate \nStep6::Step6()\n : fe_velocity(2)\n , fe_pressure(1)\n , fe(fe_velocity, dim, fe_pressure, 1)\n , velocity(0)\n , pressure(dim)\n , dof_handler(triangulation)\n{}\n\n\n\ntemplate \nvoid\nStep6::setup_system()\n{\n dof_handler.distribute_dofs(fe);\n\n solution.reinit(dof_handler.n_dofs());\n system_rhs.reinit(dof_handler.n_dofs());\n\n constraints.clear();\n DoFTools::make_hanging_node_constraints(dof_handler, constraints);\n\n\n VectorTools::interpolate_boundary_values(dof_handler,\n 0,\n Functions::ZeroFunction(dim +\n 1),\n constraints,\n fe.component_mask(velocity));\n\n constraints.close();\n\n DynamicSparsityPattern dsp(dof_handler.n_dofs());\n DoFTools::make_sparsity_pattern(dof_handler,\n dsp,\n constraints,\n /*keep_constrained_dofs = */ false);\n\n sparsity_pattern.copy_from(dsp);\n\n system_matrix.reinit(sparsity_pattern);\n}\n\n\n\ntemplate \nvoid\nStep6::assemble_system()\n{\n const QGauss quadrature_formula(fe.degree + 1);\n\n FEValues fe_values(fe,\n quadrature_formula,\n update_values | update_gradients |\n update_quadrature_points | update_JxW_values);\n\n const unsigned int dofs_per_cell = fe.dofs_per_cell;\n\n FullMatrix cell_matrix(dofs_per_cell, dofs_per_cell);\n Vector cell_rhs(dofs_per_cell);\n\n std::vector local_dof_indices(dofs_per_cell);\n\n Functions::SymbolicFunction rhs_function(\n dim == 2 ?\n \"x^2*y^2*(x - 1)^2*(2*y - 2) + 2*x^2*y*(x - 1)^2*(y - 1)^2;-x^2*y^2*(2*x - 2)*(y - 1)^2 - 2*x*y^2*(x - 1)^2*(y - 1)^2; 0\" :\n \"x^2*y^2*(x - 1)^2*(2*y - 2) + 2*x^2*y*(x - 1)^2*(y - 1)^2;-x^2*y^2*(2*x - 2)*(y - 1)^2 - 2*x*y^2*(x - 1)^2*(y - 1)^2; 0; 0\");\n\n Vector rhs_values(dim + 1);\n for (const auto &cell : dof_handler.active_cell_iterators())\n {\n cell_matrix = 0;\n cell_rhs = 0;\n\n fe_values.reinit(cell);\n\n for (const unsigned int q_index : fe_values.quadrature_point_indices())\n {\n rhs_function.vector_value(fe_values.quadrature_point(q_index),\n rhs_values);\n for (const unsigned int i : fe_values.dof_indices())\n {\n auto v = fe_values[velocity].value(i, q_index);\n auto div_v = fe_values[velocity].divergence(i, q_index);\n auto grad_v = fe_values[velocity].gradient(i, q_index);\n auto q = fe_values[pressure].value(i, q_index);\n\n for (const unsigned int j : fe_values.dof_indices())\n {\n auto div_u = fe_values[velocity].divergence(j, q_index);\n auto grad_u = fe_values[velocity].gradient(j, q_index);\n auto p = fe_values[pressure].value(j, q_index);\n\n cell_matrix(i, j) +=\n (scalar_product(grad_u, grad_v) - div_v * p - div_u * q) *\n fe_values.JxW(q_index); // dx\n }\n for (unsigned int d = 0; d < dim; ++d)\n cell_rhs(i) += (1000 * rhs_values[d] * // f(x)\n v[d] * // phi_i(x_q)\n fe_values.JxW(q_index)); // dx\n }\n }\n\n cell->get_dof_indices(local_dof_indices);\n constraints.distribute_local_to_global(\n cell_matrix, cell_rhs, local_dof_indices, system_matrix, system_rhs);\n }\n}\n\n\n\ntemplate \nvoid\nStep6::solve()\n{\n SparseDirectUMFPACK inverse;\n inverse.initialize(system_matrix);\n\n // SolverControl solver_control(1000, 1e-12);\n // SolverCG> solver(solver_control);\n\n // PreconditionSSOR> preconditioner;\n // preconditioner.initialize(system_matrix, 1.2);\n\n // solver.solve(system_matrix, solution, system_rhs, preconditioner);\n\n inverse.vmult(solution, system_rhs);\n constraints.distribute(solution);\n}\n\n\n\ntemplate \nvoid\nStep6::refine_grid()\n{\n Vector estimated_error_per_cell(triangulation.n_active_cells());\n\n KellyErrorEstimator::estimate(dof_handler,\n QGauss(fe.degree + 1),\n {},\n solution,\n estimated_error_per_cell,\n fe.component_mask(velocity));\n\n GridRefinement::refine_and_coarsen_fixed_number(triangulation,\n estimated_error_per_cell,\n 0.3,\n 0.03);\n\n triangulation.execute_coarsening_and_refinement();\n}\n\n\n\ntemplate \nvoid\nStep6::output_results(const unsigned int cycle) const\n{\n {\n std::vector solution_names(dim, \"velocity\");\n solution_names.emplace_back(\"pressure\");\n DataOutBase::VtkFlags flags;\n flags.write_higher_order_cells = true;\n\n std::vector\n data_component_interpretation(\n dim, DataComponentInterpretation::component_is_part_of_vector);\n\n data_component_interpretation.push_back(\n DataComponentInterpretation::component_is_scalar);\n DataOut data_out;\n data_out.set_flags(flags);\n\n data_out.attach_dof_handler(dof_handler);\n data_out.add_data_vector(solution,\n solution_names,\n DataOut::type_dof_data,\n data_component_interpretation);\n data_out.build_patches(fe.degree);\n\n std::ofstream output(\"solution-\" + std::to_string(cycle) + \".vtu\");\n data_out.write_vtu(output);\n }\n}\n\n\n\ntemplate \nvoid\nStep6::run()\n{\n for (unsigned int cycle = 0; cycle < 4; ++cycle)\n {\n std::cout << \"Cycle \" << cycle << ':' << std::endl;\n\n if (cycle == 0)\n {\n GridGenerator::hyper_cube(triangulation);\n triangulation.refine_global(4);\n }\n else\n refine_grid();\n\n\n std::cout << \" Number of active cells: \"\n << triangulation.n_active_cells() << std::endl;\n\n setup_system();\n\n std::cout << \" Number of degrees of freedom: \" << dof_handler.n_dofs()\n << std::endl;\n\n assemble_system();\n solve();\n output_results(cycle);\n }\n}\n\n\n\nint\nmain()\n{\n try\n {\n Step6<2> laplace_problem_2d;\n laplace_problem_2d.run();\n }\n catch (std::exception &exc)\n {\n std::cerr << std::endl\n << 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\n << 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": "ecfd2481fd8d7d720fd9dfcef79d86e839a33d3b", "size": 10114, "ext": "cc", "lang": "C++", "max_stars_repo_path": "cpp/08_saddle_point_problems/stokes.cc", "max_stars_repo_name": "luca-heltai/advanced-fem", "max_stars_repo_head_hexsha": "7dc5416db07ee67410819e4f9680471548c6641a", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2019-03-13T22:07:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-12T07:59:37.000Z", "max_issues_repo_path": "cpp/08_saddle_point_problems/stokes.cc", "max_issues_repo_name": "luca-heltai/advanced-fem", "max_issues_repo_head_hexsha": "7dc5416db07ee67410819e4f9680471548c6641a", "max_issues_repo_licenses": ["CC-BY-4.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": "cpp/08_saddle_point_problems/stokes.cc", "max_forks_repo_name": "luca-heltai/advanced-fem", "max_forks_repo_head_hexsha": "7dc5416db07ee67410819e4f9680471548c6641a", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.8622589532, "max_line_length": 132, "alphanum_fraction": 0.5625865137, "num_tokens": 2403, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737963569016, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.4999430241191715}} {"text": " #include \n #include \n #include \n #include \n #include \n #include \n #include \n\n using boost::spirit::rule;\n using boost::spirit::parser_tag;\n using boost::spirit::ch_p;\n using boost::spirit::real_p;\n\n using boost::spirit::tree_node;\n using boost::spirit::node_val_data;\n\n // The grammar\n struct parser: public boost::spirit::grammar\n {\n enum rule_ids { addsub_id, multdiv_id, value_id, real_id };\n\n struct set_value\n {\n set_value(parser const& p): self(p) {}\n void operator()(tree_node >& node,\n std::string::iterator begin,\n std::string::iterator end) const\n {\n node.value.value(self.tmp);\n }\n parser const& self;\n };\n\n mutable double tmp;\n\n template struct definition\n {\n rule > addsub;\n rule > multdiv;\n rule > value;\n rule > real;\n\n definition(parser const& self)\n {\n using namespace boost::spirit;\n addsub = multdiv\n >> *((root_node_d[ch_p('+')] | root_node_d[ch_p('-')]) >> multdiv);\n multdiv = value\n >> *((root_node_d[ch_p('*')] | root_node_d[ch_p('/')]) >> value);\n value = real | inner_node_d[('(' >> addsub >> ')')];\n real = leaf_node_d[access_node_d[real_p[assign_a(self.tmp)]][set_value(self)]];\n }\n\n rule > const& start() const\n {\n return addsub;\n }\n };\n };\n\n template\n double evaluate(TreeIter const& i)\n {\n double op1, op2;\n switch (i->value.id().to_long())\n {\n case parser::real_id:\n return i->value.value();\n case parser::value_id:\n case parser::addsub_id:\n case parser::multdiv_id:\n op1 = evaluate(i->children.begin());\n op2 = evaluate(i->children.begin()+1);\n switch(*i->value.begin())\n {\n case '+':\n return op1 + op2;\n case '-':\n return op1 - op2;\n case '*':\n return op1 * op2;\n case '/':\n return op1 / op2;\n default:\n assert(!\"Should not happen\");\n }\n default:\n assert(!\"Should not happen\");\n }\n return 0;\n }\n\n // the read/eval/write loop\n int main()\n {\n parser eval;\n std::string line;\n while (std::cout << \"Expression: \"\n && std::getline(std::cin, line)\n && !line.empty())\n {\n typedef boost::spirit::node_val_data_factory factory_t;\n boost::spirit::tree_parse_info info =\n boost::spirit::ast_parse(line.begin(), line.end(),\n eval, boost::spirit::space_p);\n if (info.full)\n {\n std::cout << \"Result: \" << evaluate(info.trees.begin()) << std::endl;\n }\n else\n {\n std::cout << \"Error in expression.\" << std::endl;\n }\n }\n };\n", "meta": {"hexsha": "6293355eda2e103c76cedbef8359592a87e0dad0", "size": 3065, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "lang/C++/arithmetic-evaluation.cpp", "max_stars_repo_name": "ethansaxenian/RosettaDecode", "max_stars_repo_head_hexsha": "8ea1a42a5f792280b50193ad47545d14ee371fb7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2018-11-09T22:08:38.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-09T22:08:38.000Z", "max_issues_repo_path": "lang/C++/arithmetic-evaluation.cpp", "max_issues_repo_name": "ethansaxenian/RosettaDecode", "max_issues_repo_head_hexsha": "8ea1a42a5f792280b50193ad47545d14ee371fb7", "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": "lang/C++/arithmetic-evaluation.cpp", "max_forks_repo_name": "ethansaxenian/RosettaDecode", "max_forks_repo_head_hexsha": "8ea1a42a5f792280b50193ad47545d14ee371fb7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-11-09T22:08:40.000Z", "max_forks_repo_forks_event_max_datetime": "2018-11-09T22:08:40.000Z", "avg_line_length": 26.1965811966, "max_line_length": 86, "alphanum_fraction": 0.5768352365, "num_tokens": 782, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737963569016, "lm_q2_score": 0.6224593312018545, "lm_q1q2_score": 0.4999430241191714}} {"text": "// Copyright (c) 2020 Sabar Nimmagadda. All rights reserved.\n\n#include \"matrix_app.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"CinderImGui.h\"\nusing Eigen::MatrixXd;\nnamespace matrixapp {\nusing cinder::app::KeyEvent;\nusing cinder::Color;\nusing cinder::ColorA;\nusing cinder::Rectf;\nusing cinder::TextBox;\nusing std::string;\nconst char kNormalFont[] = \"Arial\";\n\nMatrixApp::MatrixApp()\n : state_{AppState::kSelecting} {}\n\n\nvoid MatrixApp::setup() {\n ui::initialize();\n test_mat << 1, 2, 3,\n 4, 5, 6,\n 7, 8, 9;\n}\n\nvoid MatrixApp::update() {\n if (state_ == AppState::kInputtingData) {\n InputMatrix();\n String_To_Matrix();\n }\n}\n\nvoid MatrixApp::draw() {\n DrawBackground();\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 50};\n const Color color = Color::white();\n if (state_ == AppState::kSelecting) {\n PrintText(\"WELCOME\", color, size, {100, 50});\n CreateMenu();\n }\n if (state_ == AppState::kSolved) {\n DrawAnswer();\n }\n}\n\n\nvoid MatrixApp::CreateMenu() {\n ui::ScopedWindow window( \"Choose problem\", ImGuiWindowFlags_MenuBar );\n if( ui::BeginMenuBar() ){\n if( ui::BeginMenu( \"Problem Type\" )) {\n if (ui::MenuItem( \"RREF\" )) {\n problemType = ProblemType::RREF;\n state_= AppState::kInputtingData;\n }\n if (ui::MenuItem( \"Row Space\" )) {\n problemType = ProblemType::RowSpace;\n state_= AppState::kInputtingData;\n }\n if (ui::MenuItem( \"Column Space\")) {\n problemType = ProblemType::ColumnSpace;\n state_= AppState::kInputtingData;\n }\n if (ui::MenuItem(\"LU Decomposition\")) {\n problemType = ProblemType::LUDecomposition;\n state_= AppState::kInputtingData;\n }\n if (ui::MenuItem( \"Permutation Matrix\")) {\n problemType = ProblemType::PermutationMatrix;\n state_= AppState::kInputtingData;\n }\n if (ui::MenuItem( \"Inverse\")) {\n problemType = ProblemType::Inverse;\n state_= AppState::kInputtingData;\n }\n if (ui::MenuItem( \"Matrix Multiplication\")) {\n problemType = ProblemType::MatrixMultiplication;\n state_ = AppState::kInputtingData;\n }\n if (ui::MenuItem(\"QR Decomposition\")) {\n problemType = ProblemType::QRDecomposition;\n state_ = AppState::kInputtingData;\n }\n if (ui::MenuItem(\"Dot Product\")) {\n problemType = ProblemType::DotProduct;\n state_ = AppState::kInputtingData;\n }\n if (ui::MenuItem(\"Eigen Vectors\")) {\n problemType = ProblemType::EigenVectors;\n state_ = AppState::kInputtingData;\n }\n if (ui::MenuItem(\"Eigen Values\")) {\n problemType = ProblemType::EigenValues;\n state_ = AppState::kInputtingData;\n }\n if (ui::MenuItem(\"Determinant\")) {\n problemType = ProblemType::Determinant;\n state_ = AppState::kInputtingData;\n }\n ui::EndMenu();\n }\n ui::EndMenuBar();\n }\n const ImVec2 vec2(500, 500);\n ui::SetWindowSize(\"Choose problem\", vec2);\n}\n\n\nvoid MatrixApp::DrawAnswer() {\n if (problemType == ProblemType::QRDecomposition) {\n DrawQRAnswer(in_mat1);\n }\n if (problemType == ProblemType::LUDecomposition) {\n DrawLUAnswer(in_mat1);\n }\n if (problemType == ProblemType::PermutationMatrix) {\n DrawPermutationAnswer(in_mat1);\n }\n if (problemType == ProblemType::RREF) {\n DrawRREFAnswer(in_mat1);\n }\n if (problemType == ProblemType::EigenValues) {\n DrawEigenValuesAnswer(in_mat1);\n }\n if (problemType == ProblemType::Inverse) {\n DrawInverseAnswer(in_mat1);\n }\n if (problemType == ProblemType::EigenVectors) {\n DrawEigenVectorsAnswer(in_mat1);\n }\n if (problemType == ProblemType::DotProduct) {\n DrawDotProductAnswer(in_mat1, in_mat2);\n }\n if (problemType == ProblemType::MatrixMultiplication) {\n DrawMultiplicationAnswer(in_mat1, in_mat2);\n }\n if (problemType == ProblemType::Determinant) {\n DrawDeterminantAnswer(in_mat1);\n }\n if (problemType == ProblemType::RowSpace) {\n DrawRowSpaceAnswer(in_mat1);\n }\n if (problemType == ProblemType::ColumnSpace) {\n DrawColSpaceAnswer(in_mat1);\n }\n}\n\n\nvoid MatrixApp::keyDown(KeyEvent event) {\n}\n\nvoid MatrixApp::PrintText(const string& text, const Color color, const cinder::ivec2& size,\n const cinder::vec2& loc) {\n cinder::gl::color(color);\n auto box = TextBox()\n .alignment(TextBox::CENTER)\n .font(cinder::Font(kNormalFont, 30))\n .size(size)\n .color(color)\n .backgroundColor(ColorA(0, 0, 1, 0))\n .text(text);\n\n const auto box_size = box.getSize();\n const cinder::vec2 locp = {loc.x - box_size.x / 2, loc.y - box_size.y / 2};\n const auto surface = box.render();\n const auto texture = cinder::gl::Texture::create(surface);\n cinder::gl::draw(texture, locp);\n}\nvoid MatrixApp::DrawBackground() const {\n cinder::gl::clear(Color(0, 0, 0));\n}\nvoid MatrixApp::DrawLUAnswer(const MatrixXd& matrix) {\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 500};\n const Color color = Color::white();\n std::stringstream ss;\n ss << Computations::ComputeL(matrix);\n PrintText(\"Your L Matrix is\",color,{500,500},{center.x-50,center.y - 50});\n PrintText(ss.str(), color, size , center);\n std::stringstream st;\n st << Computations::ComputeU(matrix);\n PrintText(\"Your U Matrix is\",color,{500,500},{center.x-50,center.y + 150});\n PrintText(st.str(), color, size, {center.x, center.y + 200});\n BackToMenu();\n}\n\nvoid MatrixApp::DrawDotProductAnswer(MatrixXd matrix1, MatrixXd matrix2) {\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 500};\n const Color color = Color::white();\n std::stringstream ss;\n ss << Computations::ComputeDotProduct(std::move(matrix1), std::move(matrix2), kDimension);\n PrintText(\"Your Dot Product is\", color, {500,500},{center.x-50,center.y - 50});\n PrintText(ss.str(), color, size, center);\n BackToMenu();\n}\n\nvoid MatrixApp::DrawPermutationAnswer(MatrixXd matrix) {\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 500};\n const Color color = Color::white();\n std::stringstream ss;\n ss << Computations::ComputePermutationMatrix(std::move(matrix));\n PrintText(\"Your Permutation Matrix is\",color,{500,500},{center.x-50,center.y - 50});\n PrintText(ss.str(), color, size , center);\n BackToMenu();\n}\n\nvoid MatrixApp::DrawRREFAnswer(const MatrixXd& matrix) {\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 500};\n const Color color = Color::white();\n std::stringstream ss;\n ss << Computations::ComputeRREF(matrix);\n PrintText(\"Your Row Reduced Matrix is\",color,{500,500},{center.x-50,center.y - 50});\n PrintText(ss.str(), color, size , center);\n BackToMenu();\n}\n\nvoid MatrixApp::DrawMultiplicationAnswer(MatrixXd matrix1, MatrixXd matrix2) {\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 500};\n const Color color = Color::white();\n std::stringstream ss;\n ss << Computations::ComputeMultiply(std::move(matrix1), std::move(matrix2));\n PrintText(\"The product Matrix is\",color,{500,500},{center.x-50,center.y - 50});\n PrintText(ss.str(), color, size , center);\n BackToMenu();\n}\n\nvoid MatrixApp::DrawInverseAnswer(const MatrixXd& matrix) {\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 500};\n const Color color = Color::white();\n std::stringstream ss;\n ss << Computations::ComputeInverse(matrix);\n PrintText(\"The Inverse Matrix is\",color,{500,500},{center.x-50,center.y - 50});\n PrintText(ss.str(), color, size , center);\n BackToMenu();\n}\n\nvoid MatrixApp::DrawQRAnswer(const MatrixXd& matrix) {\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 500};\n const Color color = Color::white();\n std::stringstream ss;\n ss << Computations::ComputeQ(matrix);\n PrintText(\"Your Q Matrix is\",color,{500,500},{center.x-50,center.y - 50});\n PrintText(ss.str(), color, size , center);\n std::stringstream st;\n st << Computations::ComputeR(matrix);\n PrintText(\"Your R Matrix is\",color,{500,500},{center.x-50,center.y + 150});\n PrintText(st.str(), color, size, {center.x, center.y + 200});\n BackToMenu();\n}\n\nvoid MatrixApp::DrawEigenVectorsAnswer(MatrixXd matrix) {\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 500};\n const Color color = Color::white();\n std::stringstream ss;\n ss << Computations::ComputeEigenVectors(matrix);\n PrintText(\"The Matrix of EigenVectors is\",color,{500,500},{center.x-50,center.y - 50});\n PrintText(ss.str(), color, size , center);\n BackToMenu();\n}\n\nvoid MatrixApp::DrawEigenValuesAnswer(MatrixXd matrix) {\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 500};\n const Color color = Color::white();\n std::stringstream ss;\n ss << Computations::ComputeEigenValues(matrix);\n PrintText(\"The Eigenvalues are\",color,{500,500},{center.x-50,center.y - 50});\n PrintText(ss.str(), color, size , center);\n BackToMenu();\n}\n\nvoid MatrixApp::DrawDeterminantAnswer(const MatrixXd& matrix) {\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 500};\n const Color color = Color::white();\n std::stringstream ss;\n ss << Computations::ComputeDeterminant(matrix);\n PrintText(\"Your determinant is\", color, {500,500},{center.x-50,center.y - 50});\n PrintText(ss.str(), color, size, center);\n BackToMenu();\n}\n\nvoid MatrixApp::DrawColSpaceAnswer(const MatrixXd& matrix) {\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 500};\n const Color color = Color::white();\n std::stringstream ss;\n ss << Computations::ComputeEigenVectors(matrix.inverse());\n PrintText(\"Your Column Space Matrix is\", color, {500,500},{center.x-50,center.y - 50});\n PrintText(ss.str(), color, size, center);\n BackToMenu();\n}\n\nvoid MatrixApp::DrawRowSpaceAnswer(const MatrixXd& matrix) {\n const cinder::vec2 center = getWindowCenter();\n const cinder::ivec2 size = {500, 500};\n const Color color = Color::white();\n std::stringstream ss;\n ss << Computations::ComputeEigenVectors(matrix);\n PrintText(\"Your Row Space Matrix is\", color, {500,500},{center.x-50,center.y - 50});\n PrintText(ss.str(), color, size, center);\n BackToMenu();\n}\n\nvoid MatrixApp::InputMatrix() {\n if (problemType != ProblemType::DotProduct && problemType != ProblemType::MatrixMultiplication) {\n ui::InputInt(\"Enter dimension\", &kDimension);\n ui::InputText(\"Input matrix\", &input_string);\n } else {\n ui::InputInt(\"Enter dimension\", &kDimension);\n ui::InputText(\"Input first matrix\", &input_string);\n ui::InputText(\"Input second matrix\", &input_string2);\n str_mat2 = input_string2;\n }\n str_mat = input_string;\n}\n\n\nvoid MatrixApp::String_To_Matrix() {\n int mat_size = kDimension *kDimension;\n if ( problemType != ProblemType::DotProduct\n && problemType != ProblemType::MatrixMultiplication\n && str_mat.size() == mat_size * 2 && mat_size != 0) { // <= size * 2\n //When the computation only needs one matrix.\n std::istringstream ss(str_mat);\n for (int r = 0; r < kDimension; r++) {\n for (int c = 0; c < kDimension; c++) {\n int elem;\n ss >> elem;\n in_mat1(r, c) = elem;\n }\n }\n state_ = AppState::kSolved;\n } else if (str_mat.size() == mat_size * 2 && str_mat2.size() == mat_size * 2 && mat_size != 0){\n //Made else if instead of else, because size cannot be zero ever.\n std::istringstream ss1(str_mat);\n std::istringstream ss2(str_mat2);\n for (int r = 0; r < kDimension; r++) {\n for (int c = 0; c < kDimension; c++) {\n int elem1;\n int elem2;\n ss1 >> elem1;\n ss2 >> elem2;\n in_mat1(r, c) = elem1;\n in_mat2(r, c) = elem2;\n }\n }\n state_ = AppState::kSolved;\n }\n}\n\nvoid MatrixApp::BackToMenu() {\n const cinder::ivec2 button_size = {500, 50};\n if (ui::Button(\"BACK TO MAIN MENU\", button_size)) {\n state_ = AppState::kSelecting;\n input_string = \"\";\n input_string2 = \"\";\n kDimension = 0;\n }\n}\n\n\n} // namespace myapp\n", "meta": {"hexsha": "8ff19c59250e095040efa88d5b0e0bc3d2ad92fa", "size": 13278, "ext": "cc", "lang": "C++", "max_stars_repo_path": "apps/matrix_app.cc", "max_stars_repo_name": "CS126SP20/Matrix-Machine-LinAlgComputer-SabarNimmagadda", "max_stars_repo_head_hexsha": "928af6c373363eabc7edadf63f3e3a7220d864f1", "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": "apps/matrix_app.cc", "max_issues_repo_name": "CS126SP20/Matrix-Machine-LinAlgComputer-SabarNimmagadda", "max_issues_repo_head_hexsha": "928af6c373363eabc7edadf63f3e3a7220d864f1", "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/matrix_app.cc", "max_forks_repo_name": "CS126SP20/Matrix-Machine-LinAlgComputer-SabarNimmagadda", "max_forks_repo_head_hexsha": "928af6c373363eabc7edadf63f3e3a7220d864f1", "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.7591623037, "max_line_length": 101, "alphanum_fraction": 0.6140231963, "num_tokens": 3424, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6926419831347361, "lm_q2_score": 0.7217431943271999, "lm_q1q2_score": 0.499909637432791}} {"text": "#include \"vc.h\"\n\n#include \"cropper.h\"\n#include \"fft_plan.h\"\n#include \"tensorOps.h\"\n\n#include \n\nCx4 VBC(Cx4 &maps, Log &log)\n{\n Index const nc = maps.dimension(0);\n Index const nx = maps.dimension(1);\n Index const ny = maps.dimension(2);\n Index const nz = maps.dimension(3);\n\n Eigen::Map mat(maps.data(), nc, nx * ny * nz);\n log.info(\"VBC SVD size {}x{}\", mat.rows(), mat.cols());\n auto const svd = mat.bdcSvd(Eigen::ComputeThinV);\n Cx4 body(maps.dimensions());\n Eigen::Map bodymat(body.data(), nc, nx * ny * nz);\n bodymat = svd.matrixV().transpose();\n log.image(maps, \"vbc-maps.nii\");\n log.image(body, \"vbc-body.nii\");\n bodymat = bodymat.array().conjugate() / bodymat.array().abs();\n return body;\n}\n\nvoid VCC(Cx4 &data, Log &log)\n{\n Index const nc = data.dimension(0);\n Index const nx = data.dimension(1);\n Index const ny = data.dimension(2);\n Index const nz = data.dimension(3);\n\n // Assemble our virtual conjugate channels\n Cx4 cdata(nc, nx, ny, nz);\n FFT::Planned<5, 3> fft(cdata, log);\n cdata = data;\n log.image(cdata, \"vcc-cdata.nii\");\n fft.forward(cdata);\n log.image(cdata, \"vcc-cdata-ks.nii\");\n Cx4 rdata = cdata.slice(Sz4{0, 1, 1, 1}, Sz4{nc, nx - 1, ny - 1, nz - 1})\n .reverse(Eigen::array({false, true, true, true}))\n .conjugate();\n cdata.setZero();\n cdata.slice(Sz4{0, 1, 1, 1}, Sz4{nc, nx - 1, ny - 1, nz - 1}) = rdata;\n log.image(cdata, \"vcc-cdata-conj-ks.nii\");\n fft.reverse(cdata);\n log.image(cdata, \"vcc-cdata-conj.nii\");\n\n Cx3 phase(nx, ny, nz);\n phase.setZero();\n for (Index iz = 1; iz < nz; iz++) {\n for (Index iy = 1; iy < ny; iy++) {\n for (Index ix = 1; ix < nx; ix++) {\n Cx1 const vals = data.chip(iz, 3).chip(iy, 2).chip(ix, 1);\n Cx1 const cvals = cdata.chip(iz, 3).chip(iy, 2).chip(ix, 1).conjugate(); // Dot has a conj\n float const p = std::log(Dot(cvals, vals)).imag() / 2.f;\n phase(ix, iy, iz) = std::polar(1.f, -p);\n }\n }\n }\n log.image(phase, \"vcc-correction.nii\");\n log.info(\"Applying Virtual Conjugate Coil phase correction\");\n data = data * Tile(phase, nc);\n log.image(data, \"vcc-corrected.nii\");\n}\n\nCx3 Hammond(Cx4 const &maps, Log &log)\n{\n Index const nc = maps.dimension(0);\n Index const nx = maps.dimension(1);\n Index const ny = maps.dimension(2);\n Index const nz = maps.dimension(3);\n log.info(\"Combining images via the Hammond method\");\n\n Index const refSz = 9;\n Cropper refCrop(Sz3{nx, ny, nz}, Sz3{refSz, refSz, refSz}, log);\n Cx1 const ref =\n refCrop.crop4(maps).sum(Sz3{1, 2, 3}).conjugate() / refCrop.crop4(maps).sum(Sz3{1, 2, 3}).abs();\n\n using FixedOne = Eigen::type2index<1>;\n Eigen::IndexList rsh;\n rsh.set(0, nc);\n Eigen::IndexList brd;\n brd.set(1, nx);\n brd.set(2, ny);\n brd.set(3, nz);\n auto const broadcasted = ref.reshape(rsh).broadcast(brd);\n Cx3 const combined = (maps * broadcasted).sum(Sz1{0});\n Cx3 const rss = maps.square().sum(Sz1{0}).sqrt();\n log.image(combined, \"hammond-combined.nii\");\n log.image(rss, \"hammond-rss.nii\");\n\n return combined;\n}", "meta": {"hexsha": "a988d63b51515423a068402b239bbd4ccbcafc24", "size": 3162, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/vc.cpp", "max_stars_repo_name": "spinicist/riesling", "max_stars_repo_head_hexsha": "fa98ef1380345aa47d57ba91c970f37fe8fc5405", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2021-02-08T21:28:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T08:08:50.000Z", "max_issues_repo_path": "src/vc.cpp", "max_issues_repo_name": "spinicist/riesling", "max_issues_repo_head_hexsha": "fa98ef1380345aa47d57ba91c970f37fe8fc5405", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 29.0, "max_issues_repo_issues_event_min_datetime": "2021-02-19T11:59:33.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-24T20:45:57.000Z", "max_forks_repo_path": "src/vc.cpp", "max_forks_repo_name": "spinicist/riesling", "max_forks_repo_head_hexsha": "fa98ef1380345aa47d57ba91c970f37fe8fc5405", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2021-07-29T14:54:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-14T10:59:05.000Z", "avg_line_length": 32.9375, "max_line_length": 100, "alphanum_fraction": 0.623655914, "num_tokens": 1094, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744717487329, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.4998502938526635}} {"text": "// Copyright 2008 Chung-Lin Wen.\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\n#ifndef GIL_LAB_H\n#define GIL_LAB_H\n\n////////////////////////////////////////////////////////////////////////////////////////\n/// \\file\n/// \\brief Support for CIE Lab color space\n/// \\author Chung-Lin Wen \\n\n////////////////////////////////////////////////////////////////////////////////////////\n\n#include \n#include \n\nnamespace boost { namespace gil {\n\n/// \\addtogroup ColorNameModel\n/// \\{\nnamespace lab_color_space\n{\n/// \\brief Luminance\nstruct luminance_t {}; \n/// \\brief a Color Component\nstruct a_color_opponent_t {};\n/// \\brief b Color Component\nstruct b_color_opponent_t {}; \n}\n/// \\}\n\n/// \\ingroup ColorSpaceModel\ntypedef mpl::vector3< lab_color_space::luminance_t\n , lab_color_space::a_color_opponent_t\n , lab_color_space::b_color_opponent_t\n > lab_t;\n\n/// \\ingroup LayoutModel\ntypedef layout lab_layout_t;\n\n\nGIL_DEFINE_ALL_TYPEDEFS( 32f, lab );\n\n/// \\ingroup ColorConvert\n/// \\brief RGB to LAB\ntemplate <>\nstruct default_color_converter_impl< rgb_t, lab_t >\n{\n template \n void operator()( const P1& src, P2& dst ) const\n {\n using namespace lab_color_space;\n\n // only bits32f for lab is supported\n bits32f temp_red = channel_convert( get_color( src, red_t() ));\n bits32f temp_green = channel_convert( get_color( src, green_t() ));\n bits32f temp_blue = channel_convert( get_color( src, blue_t() ));\n\n // first, transfer to xyz color space\n bits32f normalized_r = temp_red / 255.f;\n bits32f normalized_g = temp_green / 255.f;\n bits32f normalized_b = temp_blue / 255.f;\n\n if( normalized_r > 0.04045f )\n {\n\t \t normalized_r = pow( (( normalized_r + 0.055f ) / 1.055f ), 2.4f );\n }\n\t else\n\t {\n\t \t normalized_r /= 12.92f;\n }\n\n if( normalized_g > 0.04045f )\n {\n\t \t normalized_g = pow((( normalized_g + 0.055f ) / 1.055f ), 2.4f );\n }\n\t else\n\t {\n\t \t normalized_g /= 12.92f;\n }\n\n if( normalized_b > 0.04045f )\n {\n\t \t normalized_b = pow( (( normalized_b + 0.055f ) / 1.055f ), 2.4f );\n }\n\t else\n\t {\n\t \t normalized_b /= 12.92f;\n }\n\n\t normalized_r *= 100.f;\n\t normalized_g *= 100.f;\n\t normalized_b *= 100.f;\n\n bits32f x, y, z;\n x = normalized_r * 0.4124f + normalized_g * 0.3576f + normalized_b * 0.1805f;\n y = normalized_r * 0.2126f + normalized_g * 0.7152f + normalized_b * 0.0722f;\n z = normalized_r * 0.0193f + normalized_g * 0.1192f + normalized_b * 0.9505f;\n\n // then, transfer to lab color space\n bits32f ref_x = 95.047f;\n bits32f ref_y = 100.000f;\n bits32f ref_z = 108.883f;\n bits32f normalized_x = x / ref_x;\n bits32f normalized_y = y / ref_y;\n bits32f normalized_z = z / ref_z;\n\n if( normalized_x > 0.008856f )\n {\n normalized_x = pow( normalized_x, 0.333f );\n }\n\t else\n\t {\n\t \t normalized_x = (7.787f * normalized_x) + ( 16.f/116.f );\n }\n\n if( normalized_y > 0.008856f )\n {\n\t \t normalized_y = pow( normalized_y, 0.333f );\n }\n\t else\n\t {\n\t \t normalized_y = (7.787f * normalized_y) + ( 16.f/116.f );\n }\n\n\t if( normalized_z > 0.008856f )\n\t {\n\t \t normalized_z = pow( normalized_z, 0.333f );\n }\n\t else\n\t {\n\t \t normalized_z = ( 7.787f * normalized_z ) + ( 16.f/116.f );\n }\n\n bits32f luminance, a_color_opponent, b_color_opponent;\n luminance = ( 116.f * normalized_y ) - 16.f;\n a_color_opponent = 500.f * ( normalized_x - normalized_y );\n b_color_opponent = 200.f * ( normalized_y - normalized_z );\n\n get_color( dst, luminance_t() ) = luminance;\n get_color( dst, a_color_opponent_t() ) = a_color_opponent;\n get_color( dst, b_color_opponent_t() ) = b_color_opponent;\n }\n};\n\n/// \\ingroup ColorConvert\n/// \\brief LAB to RGB\ntemplate <>\nstruct default_color_converter_impl\n{\n template \n void operator()( const P1& src, P2& dst) const\n {\n using namespace lab_color_space;\n\n bits32f luminance = get_color( src, luminance_t() );\n bits32f a_color_opponent = get_color( src, a_color_opponent_t() );\n bits32f b_color_opponent = get_color( src, b_color_opponent_t() );\n\n // first, transfer to xyz color space\n bits32f normalized_y = ( luminance + 16.f ) / 116.f;\n bits32f normalized_x = ( a_color_opponent / 500.f ) + normalized_y;\n bits32f normalized_z = normalized_y - ( b_color_opponent / 200.f );\n\n if( pow( normalized_y, 3.f ) > 0.008856f ) \n {\n normalized_y = pow( normalized_y, 3.f );\n }\n else\n {\n normalized_y = ( normalized_y - 16.f / 116.f ) / 7.787f;\n }\n\n if( pow( normalized_x, 3.f ) > 0.008856f ) \n {\n normalized_x = pow( normalized_x, 3.f );\n }\n else\n {\n normalized_x = ( normalized_x - 16.f / 116.f ) / 7.787f;\n }\n\n if( pow( normalized_z, 3.f ) > 0.008856f )\n {\n normalized_z = pow( normalized_z, 3.f );\n }\n else\n {\n normalized_z = ( normalized_z - 16.f / 116.f ) / 7.787f;\n }\n\n bits32f reference_x = 95.047f;\n bits32f reference_y = 100.000f;\n bits32f reference_z = 108.883f;\n bits32f x, y, z;\n x = reference_x * normalized_x;\n y = reference_y * normalized_y;\n z = reference_z * normalized_z;\n\n // then, transfer to rgb color space\n normalized_x = x / 100.f;\n normalized_y = y / 100.f;\n normalized_z = z / 100.f;\n\n bits32f result_r = normalized_x * 3.2406f + normalized_y * -1.5372f + normalized_z * -0.4986f;\n bits32f result_g = normalized_x * -0.9689f + normalized_y * 1.8758f + normalized_z * 0.0415f;\n bits32f result_b = normalized_x * 0.0557f + normalized_y * -0.2040f + normalized_z * 1.0570f;\n\n if( result_r > 0.0031308f )\n { \n result_r = 1.055f * pow( result_r, 1.f/2.4f ) - 0.055f;\n }\n else\n {\n result_r = 12.92f * result_r;\n }\n\n if( result_g > 0.0031308f ) \n {\n result_g = 1.055f * pow( result_g, 1.f/2.4f ) - 0.055f;\n }\n else\n {\n result_g = 12.92f * result_g;\n }\n\n if( result_b > 0.0031308f )\n {\n result_b = 1.055f * pow( result_b, 1.f/2.4f ) - 0.055f;\n }\n else\n {\n result_b = 12.92f * result_b;\n }\n\n bits32f red, green, blue;\n red = result_r * 255.f;\n green = result_g * 255.f;\n blue = result_b * 255.f;\n\n get_color(dst,red_t()) =\n channel_convert::type>( red );\n get_color(dst,green_t())=\n channel_convert::type>( green );\n get_color(dst,blue_t()) =\n channel_convert::type>( blue );\n }\n};\n\n} } // namespace boost::gil\n\n#endif // GIL_LAB_H\n", "meta": {"hexsha": "cc05960a8d8738150e74095e9823034c1325073c", "size": 7257, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "3rdparty/boost/boost/gil/extension/toolbox/lab.hpp", "max_stars_repo_name": "Greentwip/windy", "max_stars_repo_head_hexsha": "4eb8174f952c5b600ff004827a5c85dbfb013091", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2017-07-13T21:11:55.000Z", "max_stars_repo_stars_event_max_datetime": "2017-07-13T21:11:55.000Z", "max_issues_repo_path": "3rdparty/boost/boost/gil/extension/toolbox/lab.hpp", "max_issues_repo_name": "Greentwip/Windy", "max_issues_repo_head_hexsha": "4eb8174f952c5b600ff004827a5c85dbfb013091", "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": "3rdparty/boost/boost/gil/extension/toolbox/lab.hpp", "max_forks_repo_name": "Greentwip/Windy", "max_forks_repo_head_hexsha": "4eb8174f952c5b600ff004827a5c85dbfb013091", "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.34765625, "max_line_length": 101, "alphanum_fraction": 0.569656883, "num_tokens": 2170, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744673038221, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.4998502911351252}} {"text": "#include \n#include \n#include \n#include \n#include \n\n// ************************************************************************* //\n// ******************************** DATA IO ******************************** //\n// ************************************************************************* //\n\nGravitysolver::DataIO::DataIO()\n{\n epsilon = 0.0;\n}\n\nbool Gravitysolver::DataIO::readDataOld(const std::string &filename)\n{\n std::ifstream infile(filename);\n int numParticles, numGasParticles, numStarParticles;\n\n if(infile.is_open()) {\n infile >> numParticles >> numGasParticles >> numStarParticles;\n\n particles = Eigen::MatrixXf::Zero(MATRIX_DATA_ROWS, numParticles);\n\n for(int i = 0; i < numParticles; i++) {\n infile >> particles(0, i); // m\n }\n\n for(int i = 0; i < numParticles; i++) {\n infile >> particles(1, i); // x\n }\n\n for(int i = 0; i < numParticles; i++) {\n infile >> particles(2, i); // y\n }\n\n for(int i = 0; i < numParticles; i++) {\n infile >> particles(3, i); // z\n }\n\n for(int i = 0; i < numParticles; i++) {\n infile >> particles(4, i); // vx\n }\n\n for(int i = 0; i < numParticles; i++) {\n infile >> particles(5, i); // vy\n }\n\n for(int i = 0; i < numParticles; i++) {\n infile >> particles(6, i); // vz\n }\n\n return true;\n }\n\n std::cout << \"Gravitysolver::DataIO::readDataOld(\\\"\" << filename << \"\\\") \" << \"could not read file\" << std::endl;\n return false;\n}\n\nbool Gravitysolver::DataIO::readData(const std::string &filename)\n{\n std::ifstream infile(filename);\n int N;\n\n if(infile.is_open()) {\n infile >> N >> epsilon;\n particles = Eigen::MatrixXf::Zero(MATRIX_DATA_ROWS, N);\n\n float m, x, y, z, vx, vy, vz, fx, fy, fz;\n\n for(int j = 0; j < N; j++) {\n infile >> m >> x >> y >> z >> vx >> vy >> vz >> fx >> fy >> fz;\n particles(0, j) = m;\n particles(1, j) = x;\n particles(2, j) = y;\n particles(3, j) = z;\n particles(4, j) = vx;\n particles(5, j) = vy;\n particles(6, j) = vz;\n particles(7, j) = fx;\n particles(8, j) = fy;\n particles(9, j) = fz;\n }\n\n return true;\n }\n\n std::cout << \"Gravitysolver::DataIO::readData(\\\"\" << filename << \"\\\") \" << \"could not read file\" << std::endl;\n return false;\n}\n\nbool Gravitysolver::DataIO::writeData(const std::string &filename)\n{\n std::ofstream outfile(filename);\n int N = particles.cols();\n\n if(outfile.is_open()) {\n outfile << N << \" \" << epsilon << \"\\n\";\n\n for(int j = 0; j < N; j++) {\n outfile << particles(0, j) << \"\\n\"; // m\n outfile << particles(1, j) << \"\\n\"; // x\n outfile << particles(2, j) << \"\\n\"; // y\n outfile << particles(3, j) << \"\\n\"; // z\n outfile << particles(4, j) << \"\\n\"; // vx\n outfile << particles(5, j) << \"\\n\"; // vy\n outfile << particles(6, j) << \"\\n\"; // vz\n outfile << particles(7, j) << \"\\n\"; // fx\n outfile << particles(8, j) << \"\\n\"; // fy\n outfile << particles(9, j) << \"\\n\"; // fz\n }\n\n return true;\n }\n\n std::cout << \"Gravitysolver::DataIO::writeData(\\\"\" << filename << \"\\\") \" << \"could not write file\" << std::endl;\n return false;\n}\n\n// ************************************************************************* //\n// ***************************** DIRECT SOLVER ***************************** //\n// ************************************************************************* //\n\nGravitysolver::Direct::Direct()\n{\n\n}\n\nfloat Gravitysolver::Direct::softening()\n{\n return epsilon;\n}\n\nvoid Gravitysolver::Direct::setSoftening(float eps)\n{\n epsilon = eps;\n}\n\nvoid Gravitysolver::Direct::solve()\n{\n for(int i = 0; i < particles.cols(); i++) {\n particles(7, i) = .0;\n particles(8, i) = .0;\n particles(9, i) = .0;\n }\n\n float mi, mj, dx, dy, dz, sqrtInvDist, sqrtInvDist3, fx, fy, fz;\n\n for(int i = 0; i < particles.cols(); i++) {\n for(int j = i + 1; j < particles.cols(); j++) {\n mi = particles(0, i);\n mj = particles(0, j);\n dx = particles(1, i) - particles(1, j);\n dy = particles(2, i) - particles(2, j);\n dz = particles(3, i) - particles(3, j);\n\n sqrtInvDist = 1.0 / std::sqrt(dx * dx + dy * dy + dz * dz + epsilon * epsilon);\n sqrtInvDist3 = sqrtInvDist * sqrtInvDist * sqrtInvDist;\n\n // Assumption: G = 1\n fx = -mi * mj * dx * sqrtInvDist3;\n fy = -mi * mj * dy * sqrtInvDist3;\n fz = -mi * mj * dz * sqrtInvDist3;\n\n particles(7, i) += fx;\n particles(8, i) += fy;\n particles(9, i) += fz;\n particles(7, j) -= fx;\n particles(8, j) -= fy;\n particles(9, j) -= fz;\n }\n }\n}\n\nconst MatrixData &Gravitysolver::Direct::data()\n{\n return particles;\n}\n\n// ************************************************************************* //\n// ******************************* PM SOLVER ******************************* //\n// ************************************************************************* //\n\nGravitysolver::PM::PM(int numGridCells)\n{\n // The Tensor in Eigen experiences a strange case of std::bad_alloc()\n // if it has more than 776 = 2*388 complex valued elements per dimension\n if(numGridCells > 0 && numGridCells <= 388) {\n Ng = numGridCells;\n }\n else {\n std::cout << \"Gravitysolver::PM::PM(\" << numGridCells << \") numGridCells must be > 0\" << std::endl;\n Ng = 1;\n }\n\n h = .0;\n}\n\n/**\n* Returns indices for a mesh cell for the galaxy given world coordinates.\n* World coordinates have the center of the galaxy at (0, 0, 0).\n* The mapping to grid coordinates is an affine mapping where the galaxy center\n* (0, 0, 0) is in the center of the mesh as well.\n*/\nVector3i Gravitysolver::PM::worldToGrid(float x, float y, float z)\n{\n Vector3i gridCoor;\n\n gridCoor(0) = std::floor((x + (worldLen / 2)) / worldLen * Ng);\n gridCoor(1) = std::floor((y + (worldLen / 2)) / worldLen * Ng);\n gridCoor(2) = std::floor((z + (worldLen / 2)) / worldLen * Ng);\n\n return gridCoor;\n}\n\n/**\n* Returns position at the center of a mesh cell in world coordinates given cell indices\n* The position is mapped in a fashin such that (0, 0, 0) is the center of the galaxy\n* in world coordinates.\n*/\nVector3f Gravitysolver::PM::gridToWorld(int i, int j, int k)\n{\n Vector3f worldCoor;\n\n worldCoor(0) = (i * worldLen / Ng) - (worldLen / 2) + (h / 2);\n worldCoor(1) = (j * worldLen / Ng) - (worldLen / 2) + (h / 2);\n worldCoor(2) = (k * worldLen / Ng) - (worldLen / 2) + (h / 2);\n\n return worldCoor;\n}\n\nvoid Gravitysolver::PM::fft3d(FieldTensorCF &t)\n{\n const int x = t.dimension(0);\n const int y = t.dimension(1);\n const int z = t.dimension(2);\n\n Eigen::FFT fft;\n\n for(int k = 0; k < z; k++) { // for each 2d sheet make a 2d fft\n for(int j = 0; j < y; j++) { // fft in x-dir\n VectorXcf tv(x);\n for(int i = 0; i < x; i++)\n tv(i) = t(i, j, k);\n\n VectorXcf fv = fft.fwd(tv);\n for(int i = 0; i < x; i++)\n t(i, j, k) = fv(i);\n }\n\n for(int i = 0; i < x; i++) { // fft in y-dir\n VectorXcf tv(y);\n for(int j = 0; j < y; j++)\n tv(j) = t(i, j, k);\n\n VectorXcf fv = fft.fwd(tv);\n for(int j = 0; j < y; j++)\n t(i, j, k) = fv(j);\n }\n }\n\n for(int i = 0; i < x; i++) { // and for each of the x*y spikes pointing upwards in z-dir do a 1D fft\n for(int j = 0; j < y; j++) {\n\n VectorXcf tv(z);\n for(int k = 0; k < z; k++)\n tv(k) = t(i, j, k);\n\n VectorXcf fv = fft.fwd(tv);\n for(int k = 0; k < z; k++)\n t(i, j, k) = fv(k);\n }\n }\n}\n\nvoid Gravitysolver::PM::ifft3d(FieldTensorCF &t)\n{\n const int x = t.dimension(0);\n const int y = t.dimension(1);\n const int z = t.dimension(2);\n\n const float invXYZ = 1.0 / (x*y*z);\n\n for(int i = 0; i < x; i++) {\n for(int j = 0; j < y; j++) {\n for(int k = 0; k < z; k++) {\n t(i,j,k) = std::conj(t(i,j,k));\n }\n }\n }\n\n fft3d(t);\n\n for(int i = 0; i < x; i++) {\n for(int j = 0; j < y; j++) {\n for(int k = 0; k < z; k++) {\n t(i,j,k) = std::conj(t(i,j,k)) * invXYZ;\n }\n }\n }\n}\n\nvoid Gravitysolver::PM::conv3d(FieldTensorCF &out, FieldTensorCF &in, FieldTensorCF &kernel)\n{\n int x = in.dimension(0);\n int y = in.dimension(1);\n int z = in.dimension(2);\n\n fft3d(in);\n fft3d(kernel);\n\n for(int i = 0; i < x; i++) {\n for(int j = 0; j < y; j++) {\n for(int k = 0; k < z; k++) {\n out(i,j,k) = in(i,j,k) * kernel(i,j,k);\n }\n }\n }\n\n ifft3d(out);\n}\n\nvoid Gravitysolver::PM::solve()\n{\n const int N = particles.cols();\n Vector3f maxPos = particles.block(1, 0, 3, N).rowwise().maxCoeff();\n Vector3f minPosAbs = particles.block(1, 0, 3, N).rowwise().minCoeff().cwiseAbs();\n\n worldLen = std::max(maxPos.maxCoeff(), minPosAbs.maxCoeff()) * 2;\n\n // adds one layer of cells in each dimension so particles at the edge will\n // contribute with their entire mass to the density field\n worldLen += (worldLen / Ng);\n h = worldLen / Ng;\n\n std::cout << \"PM solver global parameters\" << std::endl;\n std::cout << \"---------------------------\" << std::endl;\n std::cout << \"worldLen: \" << worldLen << std::endl;\n std::cout << \"Ng: \" << Ng << std::endl;\n std::cout << \"h: \" << h << std::endl;\n std::cout << \"---------------------------\" << std::endl;\n\n density.resize(2*Ng, 2*Ng, 2*Ng);\n greenFunction.resize(2*Ng, 2*Ng, 2*Ng);\n potential.resize(2*Ng, 2*Ng, 2*Ng);\n\n ax.resize(Ng, Ng, Ng);\n ay.resize(Ng, Ng, Ng);\n az.resize(Ng, Ng, Ng);\n\n // density field construction\n for(int col = 0; col < particles.cols(); col++) {\n float m = particles(0, col);\n float px = particles(1, col);\n float py = particles(2, col);\n float pz = particles(3, col);\n\n // (NGP)\n Vector3i ti = worldToGrid(px, py, pz);\n density(ti(0), ti(1), ti(2)) += (m / (h*h*h));\n }\n\n // green's function construction\n for(int i = 0; i < Ng; i++) {\n for(int j = 0; j < Ng; j++) {\n for(int k = 0; k < Ng; k++) {\n Vector3f worldPos = gridToWorld(i, j, k);\n\n // Assumption: G = 1\n float res = -1.0 / worldPos.norm();\n\n // make the function symmetric accross all axes\n greenFunction(i, j, k) = res;\n greenFunction(i, j, 2*Ng-k-1) = res;\n greenFunction(i, 2*Ng-j-1, k) = res;\n greenFunction(i, 2*Ng-j-1, 2*Ng-k-1) = res;\n greenFunction(2*Ng-i-1, j, k) = res;\n greenFunction(2*Ng-i-1, j, 2*Ng-k-1) = res;\n greenFunction(2*Ng-i-1, 2*Ng-j-1, k) = res;\n greenFunction(2*Ng-i-1, 2*Ng-j-1, 2*Ng-k-1) = res;\n }\n }\n }\n\n // solve the poisson equation to get the potential\n conv3d(potential, density, greenFunction);\n\n // calculate acceleration field from potential\n for(int i = 1; i < Ng - 1; i++) {\n for(int j = 1; j < Ng - 1; j++) {\n for(int k = 1; k < Ng - 1; k++) {\n ax(i, j, k) = -(potential(i+1,j,k).real() - potential(i-1,j,k).real()) / (2*h);\n ay(i, j, k) = -(potential(i,j+1,k).real() - potential(i,j-1,k).real()) / (2*h);\n az(i, j, k) = -(potential(i,j,k+1).real() - potential(i,j,k-1).real()) / (2*h);\n }\n }\n }\n\n // interpolate acceleration field back from mesh to particles\n for(int col = 0; col < particles.cols(); col++) {\n float m = particles(0, col);\n float px = particles(1, col);\n float py = particles(2, col);\n float pz = particles(3, col);\n\n // (NGP)\n Vector3i ti = worldToGrid(px, py, pz);\n\n // F = m*a\n particles(7, col) = m * ax(ti(0), ti(1), ti(2));\n particles(8, col) = m * ay(ti(0), ti(1), ti(2));\n particles(9, col) = m * az(ti(0), ti(1), ti(2));\n }\n}\n\nconst MatrixData &Gravitysolver::PM::data()\n{\n return particles;\n}\n", "meta": {"hexsha": "7d248a2145d586756baf4afab8bf0103be5ab9b5", "size": 11723, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/gravitysolvers.cpp", "max_stars_repo_name": "azurite/AST-245-N-Body", "max_stars_repo_head_hexsha": "cc3e3acd61f62415c1e5f40c8aba5b93703837fa", "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/gravitysolvers.cpp", "max_issues_repo_name": "azurite/AST-245-N-Body", "max_issues_repo_head_hexsha": "cc3e3acd61f62415c1e5f40c8aba5b93703837fa", "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/gravitysolvers.cpp", "max_forks_repo_name": "azurite/AST-245-N-Body", "max_forks_repo_head_hexsha": "cc3e3acd61f62415c1e5f40c8aba5b93703837fa", "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": 27.8456057007, "max_line_length": 115, "alphanum_fraction": 0.5033694447, "num_tokens": 3722, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799929002541068, "lm_q2_score": 0.640635861701035, "lm_q1q2_score": 0.4996914237749792}} {"text": "#pragma once\n#include \n#include \n#include \"Bound3Intersect.hpp\"\n#include \"../Ray.hpp\"\n\nclass Bound3\n{\npublic:\n Bound3(Eigen::Vector3f min, Eigen::Vector3f max) : _min(min), _max(max){};\n\n Bound3Intersect intersect_ray(const Ray &ray) const\n {\n const auto &origin = ray.get_origin();\n const auto &dir = ray.get_direction();\n\n auto tIn = (_min - origin).cwiseQuotient(dir).minCoeff();\n auto tOut = (_max - origin).cwiseQuotient(dir).maxCoeff();\n\n if (tIn < std::numeric_limits::epsilon())\n return Bound3Intersect(0.0f, tOut);\n\n if (tOut - tIn > -std::numeric_limits::epsilon())\n return Bound3Intersect(tIn, tOut);\n\n return Bound3Intersect();\n };\n\n static std::unique_ptr union_bound3(const std::unique_ptr &box1, const std::unique_ptr &box2)\n {\n auto min = box1->_min.cwiseMin(box2->_min);\n auto max = box1->_max.cwiseMax(box2->_max);\n return std::make_unique(min, max);\n };\n\n const Eigen::Vector3f &min() { return _min; };\n\n const Eigen::Vector3f &max() { return _max; };\n\nprivate:\n Eigen::Vector3f _min;\n\n Eigen::Vector3f _max;\n};\n", "meta": {"hexsha": "4bea8e11303fa1eb343e92c67642bfc20641e95c", "size": 1223, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/render/accelerate/Bound3.hpp", "max_stars_repo_name": "yzx9/NeuronSdfViewer", "max_stars_repo_head_hexsha": "454164dfccf80b806aac3cd7cca09e2cb8bd3c2a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-12-31T10:29:56.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-31T10:29:56.000Z", "max_issues_repo_path": "src/render/accelerate/Bound3.hpp", "max_issues_repo_name": "yzx9/NeuronSdfViewer", "max_issues_repo_head_hexsha": "454164dfccf80b806aac3cd7cca09e2cb8bd3c2a", "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/render/accelerate/Bound3.hpp", "max_forks_repo_name": "yzx9/NeuronSdfViewer", "max_forks_repo_head_hexsha": "454164dfccf80b806aac3cd7cca09e2cb8bd3c2a", "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": 27.1777777778, "max_line_length": 121, "alphanum_fraction": 0.6287816844, "num_tokens": 347, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.779992900254107, "lm_q2_score": 0.640635854839898, "lm_q1q2_score": 0.49969141842334114}} {"text": "/*\n * SWE_Plane_Normal_Modes.hpp\n *\n * Created on: 17 Nov 2019\n * Author: Pedro Peixoto \n *\n * based on previous implementation by Martin Schreiber in swe_plane.cpp\n *\n */\n\n#ifndef SRC_PROGRAMS_SWE_PLANE_NORMAL_MODES_HPP_\n#define SRC_PROGRAMS_SWE_PLANE_NORMAL_MODES_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#if SWEET_EIGEN\n#include \n#endif\n/**\n * SWE Plane normal mode\n */\nclass SWE_Plane_Normal_Modes\n{\npublic:\n\n\ttemplate \n\tstatic\n\tvoid normal_mode_analysis(\n\t\t\tPlaneData_Spectral &io_prog_h_pert, // h: surface height (perturbation)\n\t\t\tPlaneData_Spectral &io_prog_u, // u: velocity in x-direction\n\t\t\tPlaneData_Spectral &io_prog_v, // v: velocity in y-direction\n\t\t\tint number_of_prognostic_variables,\n\t\t\tSimulationVariables &i_simVars, // Simulation variables\n\t\t\tTCallbackClass *i_class,\n\t\t\tvoid(TCallbackClass::* const i_run_timestep_method)(void)\n\t)\n\t{\n\n\t\tconst PlaneDataConfig *planeDataConfig = io_prog_h_pert.planeDataConfig;\n\n\t\t// dummy time step to get time step size\n\t\tif (i_simVars.timecontrol.current_timestep_size <= 0)\n\t\t\tSWEETError(\"Normal mode analysis requires setting fixed time step size\");\n\n\t\t/*\n\t\t *\n\t\t * Mode-wise normal mode analysis\n\t\t *\n\t\t *\n\t\t */\n\n\t\tif (i_simVars.misc.normal_mode_analysis_generation == 4)\n\t\t{\n#if SWEET_EIGEN\n#if SWEET_USE_PLANE_SPECTRAL_DEALIASING\n\t\t\tSWEETError(\"SWE_Plane_Normal_Modes: This test was build for linear or linearized models, so please compile without dealising --plane-spectral-dealiasing=disable.\");\n#endif\n\n\n\t\t\t/*\n\t\t\t * Setup all output files\n\t\t\t */\n\t\t\tconst char* filename; //general filename\n\t\t\tchar buffer_real[1024];\n\n\t\t\tif (i_simVars.iodata.output_file_name == \"\")\n\t\t\t\tfilename = \"output_%s_t%020.8f.csv\";\n\t\t\telse\n\t\t\t\tfilename = i_simVars.iodata.output_file_name.c_str();\n\n\t\t\tsprintf(buffer_real, filename, \"normal_modes_plane\", i_simVars.timecontrol.current_timestep_size*i_simVars.iodata.output_time_scale);\n\t\t\tstd::ofstream file(buffer_real, std::ios_base::trunc);\n\t\t\tstd::cout << \"Writing normal mode analysis to files of the form '\" << buffer_real << \"'\" << std::endl;\n\n\t\t\t//Positive inertia-gravity modes\n\t\t\tsprintf(buffer_real, filename, \"normal_modes_plane_igpos\", i_simVars.timecontrol.current_timestep_size*i_simVars.iodata.output_time_scale);\n\t\t\tstd::ofstream file_igpos(buffer_real, std::ios_base::trunc);\n\n\t\t\t//Negative inertia-gravity modes\n\t\t\tsprintf(buffer_real, filename, \"normal_modes_plane_igneg\", i_simVars.timecontrol.current_timestep_size*i_simVars.iodata.output_time_scale);\n\t\t\tstd::ofstream file_igneg(buffer_real, std::ios_base::trunc);\n\n\t\t\t//Geostrophic modes\n\t\t\tsprintf(buffer_real, filename, \"normal_modes_plane_geo\", i_simVars.timecontrol.current_timestep_size*i_simVars.iodata.output_time_scale);\n\t\t\tstd::ofstream file_geo(buffer_real, std::ios_base::trunc);\n\n\t\t\t//std::cout << \"WARNING: OUTPUT IS TRANSPOSED!\" << std::endl;\n\n\t\t\t// use very high precision\n\t\t\tfile << std::setprecision(20);\n\t\t\tfile_igpos << std::setprecision(20);\n\t\t\tfile_igneg << std::setprecision(20);\n\t\t\tfile_geo << std::setprecision(20);\n\n\t\t\tfile << \"# dt \" << i_simVars.timecontrol.current_timestep_size << std::endl;\n\t\t\tfile << \"# g \" << i_simVars.sim.gravitation << std::endl;\n\t\t\tfile << \"# h \" << i_simVars.sim.h0 << std::endl;\n\t\t\tfile << \"# r \" << i_simVars.sim.sphere_radius << std::endl;\n\t\t\tfile << \"# f \" << i_simVars.sim.plane_rotating_f0 << std::endl;\n\n#if SWEET_USE_PLANE_SPECTRAL_SPACE\n\t\t\tint specmodes = planeDataConfig->get_spectral_iteration_range_area(0)+planeDataConfig->get_spectral_iteration_range_area(1);\n\t\t\tfile << \"# specnummodes \" << specmodes << std::endl;\n\t\t\tfile << \"# specrealresx \" << planeDataConfig->spectral_real_modes[0] << std::endl;\n\t\t\tfile << \"# specrealresy \" << planeDataConfig->spectral_real_modes[1] << std::endl;\n#endif\n\n\t\t\tfile << \"# physresx \" << planeDataConfig->physical_res[0] << std::endl;\n\t\t\tfile << \"# physresy \" << planeDataConfig->physical_res[1] << std::endl;\n\t\t\tfile << \"# normalmodegeneration \" << i_simVars.misc.normal_mode_analysis_generation << std::endl;\n\t\t\tfile << \"# antialiasing \";\n#if SWEET_USE_PLANE_SPECTRAL_DEALIASING\n\t\t\tfile << 1;\n#else\n\t\t\tfile << 0;\n#endif\n\t\t\tfile << std::endl;\n\n\t\t\tPlaneData_Spectral* prog[3] = {&io_prog_h_pert, &io_prog_u, &io_prog_v};\n\n\t\t\tint number_of_prognostic_variables = 3;\n\t\t\t//The basic state is with zero in all variables\n\t\t\t// The only non zero variable in the basic state is the total height\n\t\t\t// for which the constant is added within run_timestep()\n\t\t\tio_prog_h_pert.spectral_set_zero();\n\t\t\tio_prog_u.spectral_set_zero();\n\t\t\tio_prog_v.spectral_set_zero();\n\n\t\t\t//int num_timesteps = 1;\n\n\t\t\t// Timestep and perturbation\n\t\t\tdouble dt = i_simVars.timecontrol.current_timestep_size;\n\t\t\tdouble eps = dt;\n\n\t\t\t//Matrix representing discrete linear operator in spectral space\n\t\t\tEigen::MatrixXcf A(3,3) ;\n\t\t\t//Eigen solver\n\t\t\tEigen::ComplexEigenSolver ces;\n\t\t\t//Final eigenvalues\n\t\t\tstd::complex eval[3];\n\n\t\t\t//For each spectral mode\n\t\t\t//for (int r = 0; r < 2; r++) //only required to get the symmetric half of the spectrum\n\t\t\t//{\n\t\t\tint r = 0;\n\n\t\t\tfor (std::size_t i = planeDataConfig->spectral_data_iteration_ranges[r][0][0]; i < planeDataConfig->spectral_data_iteration_ranges[r][0][1]; i++)\n\t\t\t{\n\t\t\t\tstd::cout << \".\" << std::flush;\n\t\t\t\tfor (std::size_t j = planeDataConfig->spectral_data_iteration_ranges[r][1][0]; j < planeDataConfig->spectral_data_iteration_ranges[r][1][1]; j++)\n\t\t\t\t{\n\t\t\t\t\t//This is the mode to be analysed\n\t\t\t\t\t//std::cout << \"Mode (i,j)= (\" << i << \" , \" << j <<\")\"<< std::endl;\n\n\n\t\t\t\t\tfor (int outer_prog_id = 0; outer_prog_id < number_of_prognostic_variables; outer_prog_id++)\n\t\t\t\t\t{\n\n\t\t\t\t\t\t// reset time control\n\t\t\t\t\t\ti_simVars.timecontrol.current_timestep_nr = 0;\n\t\t\t\t\t\ti_simVars.timecontrol.current_simulation_time = 0;\n\n\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t\tprog[inner_prog_id]->spectral_set_zero();\n\n\t\t\t\t\t\t// activate mode via real coefficient\n\t\t\t\t\t\tprog[outer_prog_id]->spectral_set(j, i, 1.0);\n\t\t\t\t\t\t//Activate the symetric couterpart of the mode (only needed if j>0 )\n\t\t\t\t\t\tif (j > 0)\n\t\t\t\t\t\t\tprog[outer_prog_id]->spectral_set(planeDataConfig->spectral_data_size[1]-j, i, 1.0);\n\n\t\t\t\t\t\t/*\n\t\t\t\t\t\t * RUN timestep\n\t\t\t\t\t\t */\n\t\t\t\t\t\t////prog[outer_prog_id]->request_data_physical();\n\t\t\t\t\t\t(i_class->*i_run_timestep_method)();\n\n\t\t\t\t\t\t/*\n\t\t\t\t\t\t * compute\n\t\t\t\t\t\t * 1/dt * (U(t+1) - U(t))\n\t\t\t\t\t\t */\n\t\t\t\t\t\t///////prog[outer_prog_id]->request_data_spectral();\n\n\t\t\t\t\t\tstd::complex val = prog[outer_prog_id]->spectral_get(j, i);\n\t\t\t\t\t\tval = val - 1.0; //subtract U(0) from mode\n\t\t\t\t\t\tprog[outer_prog_id]->spectral_set(j, i, val);\n\n\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t\t(*prog[inner_prog_id]) /= eps;\n\n\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tA(inner_prog_id,outer_prog_id)=prog[inner_prog_id]->spectral_get(j, i);;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t\t//std::cout << \"Lik matrix\" << std::endl;\n\t\t\t\t\t//std::cout << A << std::endl;\n\n\t\t\t\t\t//std::cout<<\"Normal modes\" << std::endl;\n\t\t\t\t\tces.compute(A);\n\t\t\t\t\tfor(int i=0; i<3; i++)\n\t\t\t\t\t{\n\t\t\t\t\t\teval[i]=ces.eigenvalues()[i];\n\t\t\t\t\t\t//std::cout << \"Eigenvalue \"<< i << \" : \" << eval[i].real() <<\" \"<f) - we will adopt coriolis f to test as if > zero, since the exact freq is sqrt(f^2+cK*K)\n\t\t\t\t\t * -negative inertia-gravity (imag<-f)\n\t\t\t\t\t * -negative inertia-gravity (imag aprox 0) - we will fit all other modes here\n\t\t\t\t\t */\n\t\t\t\t\tint count_igpos=0;\n\t\t\t\t\tint count_igneg=0;\n\t\t\t\t\tint count_geo=0;\n\t\t\t\t\tfor(int i=0; i<3; i++)\n\t\t\t\t\t{\n\t\t\t\t\t\tif(eval[i].imag() > 0.5 * i_simVars.sim.plane_rotating_f0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t//std::cout<< \"IG pos mode: \" << eval[i].imag() << std::endl;\n\t\t\t\t\t\t\t//file_igpos << eval[i].imag();\n\t\t\t\t\t\t\tfile_igpos << eval[i].real()<< \"\\t\" << eval[i].imag();\n\t\t\t\t\t\t\tfile_igpos << \"\\t\";\n\t\t\t\t\t\t\tcount_igpos++;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif(eval[i].imag() < - 0.5 * i_simVars.sim.plane_rotating_f0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t//std::cout<< \"IG neg mode: \" << eval[i].imag() << std::endl;\n\t\t\t\t\t\t\t//file_igneg << eval[i].imag();\n\t\t\t\t\t\t\tfile_igneg << eval[i].real()<< \"\\t\" << eval[i].imag();\n\t\t\t\t\t\t\tfile_igneg << \"\\t\";\n\t\t\t\t\t\t\tcount_igneg++;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif(eval[i].imag() >= - 0.5 * i_simVars.sim.plane_rotating_f0 && eval[i].imag() <= 0.5 * i_simVars.sim.plane_rotating_f0 )\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t//std::cout<< \"IG geo mode: \" << eval[i].imag() << std::endl;\n\t\t\t\t\t\t\t//file_geo << eval[i].imag();\n\t\t\t\t\t\t\tfile_geo << eval[i].real()<< \"\\t\" << eval[i].imag();\n\t\t\t\t\t\t\tfile_geo << \"\\t\";\n\t\t\t\t\t\t\tcount_geo++;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\t//Check if we got the correct modes\n\t\t\t\t\tif ( count_igpos * count_igneg * count_geo > 0 )\n\t\t\t\t\t{\n\t\t\t\t\t\tcount_igpos=0;\n\t\t\t\t\t\tcount_igneg=0;\n\t\t\t\t\t\tcount_geo=0;\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t{\n\t\t\t\t\t\tSWEETError(\"SWE_Plane_Normal_Modes: Could not separate modes!!\");\n\t\t\t\t\t}\n\n\t\t\t\t\t//std::cout<<\"-------------------------\" << std::endl;\n\t\t\t\t}\n\t\t\t\tfile_igpos << std::endl;\n\t\t\t\tfile_igneg << std::endl;\n\t\t\t\tfile_geo << std::endl;\n\t\t\t}\n\n\t\t\t//}\n\t\t\t//std::cout<<\"-------------------------\" << std::endl;\n\t\t\t//SWEETError(\"still needs work...\");\n#else\n\t\t\tSWEETError(\"SWE_Plane_Normal_Modes: Cannot test this without Eigen library. Please compile with --eigen=enable\");\n#endif\n\t\t}\n\t\t/*\n\t\t * Do a normal mode analysis using perturbation, see\n\t\t * Hillary Weller, John Thuburn, Collin J. Cotter,\n\t\t * \"Computational Modes and Grid Imprinting on Five Quasi-Uniform Spherical C Grids\"\n\t\t */\n\t\telse\n\t\t{\n\n\t\t\t//run_timestep();\n\t\t\tconst char* filename;\n\t\t\tchar buffer_real[1024];\n\n\t\t\tif (i_simVars.iodata.output_file_name == \"\")\n\t\t\t\tfilename = \"output_%s_normalmodes.csv\";\n\t\t\telse\n\t\t\t\tfilename = i_simVars.iodata.output_file_name.c_str();\n\n\n\t\t\tsprintf(buffer_real, filename, \"normal_modes_physical\", i_simVars.timecontrol.current_timestep_size*i_simVars.iodata.output_time_scale);\n\t\t\tstd::ofstream file(buffer_real, std::ios_base::trunc);\n\t\t\tstd::cout << \"Writing normal mode analysis to file '\" << buffer_real << \"'\" << std::endl;\n\n\t\t\tstd::cout << \"WARNING: OUTPUT IS TRANSPOSED!\" << std::endl;\n\n\t\t\t// use very high precision\n\t\t\tfile << std::setprecision(20);\n\n\t\t\tPlaneData_Spectral* prog[3] = {&io_prog_h_pert, &io_prog_u, &io_prog_v};\n\n\t\t\t/*\n\t\t\t * Maximum number of prognostic variables\n\t\t\t *\n\t\t\t * Advection e.g. has only one\n\t\t\t */\n\t\t\tif (number_of_prognostic_variables <= 0)\n\t\t\t\tSWEETError(\"simVars.pde.number_of_prognostic_variables must be set!\");\n\n\t\t\tif (number_of_prognostic_variables == 3)\n\t\t\t{\n\t\t\t\tio_prog_h_pert.spectral_set_zero();\n\t\t\t\tio_prog_u.spectral_set_zero();\n\t\t\t\tio_prog_v.spectral_set_zero();\n\t\t\t}\n\t\t\telse if (number_of_prognostic_variables == 1)\n\t\t\t{\n\t\t\t\tio_prog_h_pert.spectral_set_zero();\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tSWEETError(\"Not yet supported\");\n\t\t\t}\n\n#if 0\n\t\t\tif (i_simVars.disc.timestepping_method == SimulationVariables::Discretization::LEAPFROG_EXPLICIT)\n\t\t\t{\n\t\t\t\tSWEETError(\"Not yet tested and supported\");\n\t\t\t\tstd::cout << \"WARNING: Leapfrog time stepping doesn't make real sense since 1st step is based on RK-like method\" << std::endl;\n\t\t\t\tstd::cout << \"We'll do two Leapfrog time steps here to take the LF errors into account!\" << std::endl;\n\t\t\t\tstd::cout << \"Therefore, we also halve the time step size here\" << std::endl;\n\n\t\t\t\ti_simVars.timecontrol.current_timestep_size = 0.5*i_simVars.sim.CFL;\n\t\t\t\ti_simVars.sim.CFL = -i_simVars.timecontrol.current_timestep_size;\n\t\t\t}\n#endif\n\n\t\t\tint num_timesteps = 1;\n\t\t\tif (i_simVars.misc.normal_mode_analysis_generation >= 10)\n\t\t\t{\n\t\t\t\tif (i_simVars.timecontrol.max_timesteps_nr > 0)\n\t\t\t\t\tnum_timesteps = i_simVars.timecontrol.max_timesteps_nr;\n\t\t\t}\n\n\t\t\tif (i_simVars.timecontrol.max_simulation_time > 0)\n\t\t\t\tfile << \"# t \" << i_simVars.timecontrol.max_simulation_time << std::endl;\n\t\t\telse\n\t\t\t\tfile << \"# t \" << (num_timesteps*(-i_simVars.timecontrol.current_timestep_size)) << std::endl;\n\n\t\t\tfile << \"# g \" << i_simVars.sim.gravitation << std::endl;\n\t\t\tfile << \"# h \" << i_simVars.sim.h0 << std::endl;\n//\t\t\tfile << \"# r \" << i_simVars.sim.sphere_radius << std::endl;\n\t\t\tfile << \"# f \" << i_simVars.sim.plane_rotating_f0 << std::endl;\n\n#if SWEET_USE_PLANE_SPECTRAL_SPACE\n\t\t\tint specmodes = planeDataConfig->get_spectral_iteration_range_area(0)+planeDataConfig->get_spectral_iteration_range_area(1);\n\t\t\tfile << \"# specnummodes \" << specmodes << std::endl;\n\t\t\tfile << \"# specrealresx \" << planeDataConfig->spectral_real_modes[0] << std::endl;\n\t\t\tfile << \"# specrealresy \" << planeDataConfig->spectral_real_modes[1] << std::endl;\n#endif\n\n\t\t\tfile << \"# physresx \" << planeDataConfig->physical_res[0] << std::endl;\n\t\t\tfile << \"# physresy \" << planeDataConfig->physical_res[1] << std::endl;\n\t\t\tfile << \"# normalmodegeneration \" << i_simVars.misc.normal_mode_analysis_generation << std::endl;\n\t\t\tfile << \"# antialiasing \";\n\n#if SWEET_USE_PLANE_SPECTRAL_DEALIASING\n\t\t\tfile << 1;\n#else\n\t\t\tfile << 0;\n#endif\n\n\t\t\tfile << std::endl;\n\n\n\t\t\t// iterate over all prognostic variables\n\t\t\tfor (int outer_prog_id = 0; outer_prog_id < number_of_prognostic_variables; outer_prog_id++)\n\t\t\t{\n\t\t\t\tif (i_simVars.misc.normal_mode_analysis_generation == 1 || i_simVars.misc.normal_mode_analysis_generation == 11)\n\t\t\t\t{\n\t\t\t\t\t// iterate over physical space\n\t\t\t\t\tfor (std::size_t outer_i = 0; outer_i < planeDataConfig->physical_array_data_number_of_elements; outer_i++)\n\t\t\t\t\t{\n\t\t\t\t\t\t// reset time control\n\t\t\t\t\t\ti_simVars.timecontrol.current_timestep_nr = 0;\n\t\t\t\t\t\ti_simVars.timecontrol.current_simulation_time = 0;\n\n\t\t\t\t\t\tstd::cout << \".\" << std::flush;\n\n\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t\tprog[inner_prog_id]->spectral_set_zero();\n\n\t\t\t\t\t\t// activate mode\n\t\t\t\t\t\t///prog[outer_prog_id]->request_data_physical();\n\t\t\t\t\t\t///prog[outer_prog_id]->physical_space_data[outer_i] = 1;\n\t\t\t\t\t\tPlaneData_Physical tmp = prog[outer_prog_id]->toPhys();\n\t\t\t\t\t\ttmp.physical_space_data[outer_i] = 1;\n\t\t\t\t\t\tprog[outer_prog_id]->loadPlaneDataPhysical(tmp);\n\n\t\t\t\t\t\t/*\n\t\t\t\t\t\t * RUN timestep\n\t\t\t\t\t\t */\n\n\t\t\t\t\t\t(i_class->*i_run_timestep_method)();\n\n\t\t\t\t\t\tif (i_simVars.misc.normal_mode_analysis_generation == 1)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t/*\n\t\t\t\t\t\t\t * compute\n\t\t\t\t\t\t\t * 1/dt * (U(t+1) - U(t))\n\t\t\t\t\t\t\t */\n\t\t\t\t\t\t\t///////prog[outer_prog_id]->request_data_physical();\n\t\t\t\t\t\t\t///////prog[outer_prog_id]->physical_space_data[outer_i] -= 1.0;\n\t\t\t\t\t\t\tPlaneData_Physical tmp2 = prog[outer_prog_id]->toPhys();\n\t\t\t\t\t\t\ttmp2.physical_space_data[outer_i] -= 1.0;\n\n\t\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t\t\ttmp2 /= i_simVars.timecontrol.current_timestep_size;\n\t\t\t\t\t\t\t\t//(*prog[inner_prog_id]) /= i_simVars.timecontrol.current_timestep_size;\n\n\t\t\t\t\t\t\tprog[outer_prog_id]->loadPlaneDataPhysical(tmp2);\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\ttmp = prog[outer_prog_id]->toPhys();\n\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t///prog[inner_prog_id]->request_data_physical();\n\t\t\t\t\t\t\tfor (std::size_t k = 0; k < planeDataConfig->physical_array_data_number_of_elements; k++)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t///file << prog[inner_prog_id]->physical_space_data[k];\n\t\t\t\t\t\t\t\tfile << tmp.physical_space_data[k];\n\t\t\t\t\t\t\t\tif (inner_prog_id != number_of_prognostic_variables-1 || k != planeDataConfig->physical_array_data_number_of_elements-1)\n\t\t\t\t\t\t\t\t\tfile << \"\\t\";\n\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\tfile << std::endl;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n#if 1\n\t\t\t\telse if (i_simVars.misc.normal_mode_analysis_generation == 3 || i_simVars.misc.normal_mode_analysis_generation == 13)\n\t\t\t\t{\n#if !SWEET_USE_PLANE_SPECTRAL_SPACE\n\t\t\t\t\tSWEETError(\"Only available with if plane spectral space is activated during compile time!\");\n#else\n\n\t\t\t\t\t// iterate over spectral space\n\t\t\t\t\tfor (int r = 0; r < 2; r++)\n\t\t\t\t\t{\n\n\t\t\t\t\t\tfor (std::size_t j = planeDataConfig->spectral_data_iteration_ranges[r][1][0]; j < planeDataConfig->spectral_data_iteration_ranges[r][1][1]; j++)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfor (std::size_t i = planeDataConfig->spectral_data_iteration_ranges[r][0][0]; i < planeDataConfig->spectral_data_iteration_ranges[r][0][1]; i++)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t// reset time control\n\t\t\t\t\t\t\t\ti_simVars.timecontrol.current_timestep_nr = 0;\n\t\t\t\t\t\t\t\ti_simVars.timecontrol.current_simulation_time = 0;\n\n\t\t\t\t\t\t\t\tstd::cout << \".\" << std::flush;\n\n\t\t\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t\t\t\tprog[inner_prog_id]->spectral_set_zero();\n\n\t\t\t\t\t\t\t\t// activate mode via real coefficient\n\t\t\t\t\t\t\t\tprog[outer_prog_id]->spectral_set(j, i, 1.0);\n\n\t\t\t\t\t\t\t\t/*\n\t\t\t\t\t\t\t\t * RUN timestep\n\t\t\t\t\t\t\t\t */\n\t\t\t\t\t\t\t\t(i_class->*i_run_timestep_method)();\n\n\n\t\t\t\t\t\t\t\tif (i_simVars.misc.normal_mode_analysis_generation == 3)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t/*\n\t\t\t\t\t\t\t\t\t * compute\n\t\t\t\t\t\t\t\t\t * 1/dt * (U(t+1) - U(t))\n\t\t\t\t\t\t\t\t\t */\n\t\t\t\t\t\t\t\t\t///prog[outer_prog_id]->request_data_spectral();\n\n\t\t\t\t\t\t\t\t\tstd::complex val = prog[outer_prog_id]->spectral_get(j, i);\n\t\t\t\t\t\t\t\t\tval = val - 1.0;\n\t\t\t\t\t\t\t\t\tprog[outer_prog_id]->spectral_set(j, i, val);\n\n\t\t\t\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t\t\t\t\t(*prog[inner_prog_id]) /= i_simVars.timecontrol.current_timestep_size;\n\t\t\t\t\t\t\t\t}\n\n\n\t\t\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t///prog[inner_prog_id]->request_data_spectral();\n\n\t\t\t\t\t\t\t\t\t/*\n\t\t\t\t\t\t\t\t\t * REAL\n\t\t\t\t\t\t\t\t\t */\n\n\t\t\t\t\t\t\t\t\tfor (int r = 0; r < 2; r++)\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\tfor (std::size_t j = planeDataConfig->spectral_data_iteration_ranges[r][1][0]; j < planeDataConfig->spectral_data_iteration_ranges[r][1][1]; j++)\n\t\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\t\tfor (std::size_t i = planeDataConfig->spectral_data_iteration_ranges[r][0][0]; i < planeDataConfig->spectral_data_iteration_ranges[r][0][1]; i++)\n\t\t\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\t\t\tfile << prog[inner_prog_id]->spectral_get(j, i).real();\n\t\t\t\t\t\t\t\t\t\t\t\tfile << \"\\t\";\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\n\n\t\t\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t/*\n\t\t\t\t\t\t\t\t\t * IMAG\n\t\t\t\t\t\t\t\t\t */\n\t\t\t\t\t\t\t\t\tint c = 0;\n\t\t\t\t\t\t\t\t\tfor (int r = 0; r < 2; r++)\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\tfor (std::size_t j = planeDataConfig->spectral_data_iteration_ranges[r][1][0]; j < planeDataConfig->spectral_data_iteration_ranges[r][1][1]; j++)\n\t\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\t\tfor (std::size_t i = planeDataConfig->spectral_data_iteration_ranges[r][0][0]; i < planeDataConfig->spectral_data_iteration_ranges[r][0][1]; i++)\n\t\t\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\t\t\tfile << prog[inner_prog_id]->spectral_get(j, i).imag();\n\n\t\t\t\t\t\t\t\t\t\t\t\tif (inner_prog_id != number_of_prognostic_variables-1 || c != specmodes-1)\n\t\t\t\t\t\t\t\t\t\t\t\t\tfile << \"\\t\";\n\t\t\t\t\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\t\t\t\t\tfile << std::endl;\n\n\t\t\t\t\t\t\t\t\t\t\t\tc++;\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n#endif\n\t\t\t\t}\n#else\n\t\t\t\telse if (i_simVars.misc.normal_mode_analysis_generation == 3 || i_simVars.misc.normal_mode_analysis_generation == 13)\n\t\t\t\t{\n\t\t\t\t\tPlaneData_SpectralComplex t1(planeDataConfig);\n\t\t\t\t\tPlaneData_SpectralComplex t2(planeDataConfig);\n\t\t\t\t\tPlaneData_SpectralComplex t3(planeDataConfig);\n\t\t\t\t\tPlaneDataComplex* prog_cplx[3] = {&t1, &t2, &t3};\n\n\t\t\t\t\t// iterate over spectral space\n\t\t\t\t\tfor (std::size_t outer_i = 0; outer_i < planeDataConfig->spectral_complex_array_data_number_of_elements; outer_i++)\n\t\t\t\t\t{\n\t\t\t\t\t\t// reset time control\n\t\t\t\t\t\ti_simVars.timecontrol.current_timestep_nr = 0;\n\t\t\t\t\t\ti_simVars.timecontrol.current_simulation_time = 0;\n\n\t\t\t\t\t\tstd::cout << \".\" << std::flush;\n\n\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t\tprog_cplx[inner_prog_id]->spectral_set_zero();\n\n\t\t\t\t\t\t// activate mode via real coefficient\n\t\t\t\t\t\tprog_cplx[outer_prog_id]->request_data_spectral();\n\t\t\t\t\t\tprog_cplx[outer_prog_id]->spectral_space_data[outer_i].real(1);\n\n\t\t\t\t\t\t// convert PlaneData_SpectralComplex to PlaneData\n\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t*prog[inner_prog_id] = Convert_PlaneDataSpectralComplex_To_PlaneDataSpectral::physical_convert(*prog_cplx[inner_prog_id]);\n\t\t\t\t\t\t\tprog[inner_prog_id]->spectral_zeroAliasingModes();\n\t\t\t\t\t\t}\n\n\n\t\t\t\t\t\t/*\n\t\t\t\t\t\t * RUN timestep\n\t\t\t\t\t\t */\n\t\t\t\t\t\t(i_class->*i_run_timestep_method)();\n\n\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tprog[inner_prog_id]->spectral_zeroAliasingModes();\n#warning \"update this physical_convert maybe to spectral_convert\"\n\n\t\t\t\t\t\t\t*prog_cplx[inner_prog_id] = Convert_PlaneDataSpectral_To_PlaneDataSpectralComplex::physical_convert(*prog[inner_prog_id]);\n\n\t\t\t\t\t\t\tprog_cplx[inner_prog_id]->request_data_spectral();\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (i_simVars.misc.normal_mode_analysis_generation == 3)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t/*\n\t\t\t\t\t\t\t * compute\n\t\t\t\t\t\t\t * 1/dt * (U(t+1) - U(t))\n\t\t\t\t\t\t\t */\n\t\t\t\t\t\t\tprog_cplx[outer_prog_id]->request_data_spectral();\n\t\t\t\t\t\t\tprog_cplx[outer_prog_id]->spectral_space_data[outer_i] -= 1.0;\n\n\t\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t\t\tprog_cplx[inner_prog_id]->operator*=(1.0/i_simVars.timecontrol.current_timestep_size);\n\t\t\t\t\t\t}\n\n\n\t\t\t\t\t\t// convert PlaneData_SpectralComplex to PlaneData\n\t\t\t\t\t\tfor (int inner_prog_id = 0; inner_prog_id < number_of_prognostic_variables; inner_prog_id++)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tprog_cplx[inner_prog_id]->request_data_spectral();\n\n\t\t\t\t\t\t\t/*\n\t\t\t\t\t\t\t * REAL\n\t\t\t\t\t\t\t */\n\t\t\t\t\t\t\tfor (std::size_t k = 0; k < planeDataConfig->spectral_complex_array_data_number_of_elements; k++)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tfile << prog_cplx[inner_prog_id]->spectral_space_data[k].real();\n\t\t\t\t\t\t\t\tfile << \"\\t\";\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t/*\n\t\t\t\t\t\t\t * IMAG\n\t\t\t\t\t\t\t */\n\t\t\t\t\t\t\tfor (std::size_t k = 0; k < planeDataConfig->spectral_complex_array_data_number_of_elements; k++)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tfile << prog_cplx[inner_prog_id]->spectral_space_data[k].imag();\n\n\t\t\t\t\t\t\t\tif (inner_prog_id != number_of_prognostic_variables-1 || k != planeDataConfig->spectral_complex_array_data_number_of_elements-1)\n\t\t\t\t\t\t\t\t\tfile << \"\\t\";\n\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\tfile << std::endl;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n#endif\n\t\t\t}\n\t\t}\n\t}\n\n\n\t~SWE_Plane_Normal_Modes()\n\t{\n\n\t}\n};\n\n#endif /* SRC_PROGRAMS_SWE_PLANE_NORMAL_MODES_HPP_ */\n", "meta": {"hexsha": "00e8ca51c1637e5bf29df4c8f6dbb970bc26ce3e", "size": 22579, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/programs/swe_plane_timeintegrators/SWE_Plane_Normal_Modes.hpp", "max_stars_repo_name": "schreibm/sweet", "max_stars_repo_head_hexsha": "a1b97e5862c3871177dff877dff825fd4b98a085", "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/programs/swe_plane_timeintegrators/SWE_Plane_Normal_Modes.hpp", "max_issues_repo_name": "schreibm/sweet", "max_issues_repo_head_hexsha": "a1b97e5862c3871177dff877dff825fd4b98a085", "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/programs/swe_plane_timeintegrators/SWE_Plane_Normal_Modes.hpp", "max_forks_repo_name": "schreibm/sweet", "max_forks_repo_head_hexsha": "a1b97e5862c3871177dff877dff825fd4b98a085", "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.9520123839, "max_line_length": 167, "alphanum_fraction": 0.6523318127, "num_tokens": 6399, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.779992900254107, "lm_q2_score": 0.640635854839898, "lm_q1q2_score": 0.49969141842334114}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nusing namespace std;\nusing namespace boost::gil;\n\n// value of strong edge pixel\nstatic const int TOP_VALUE = 255;\n// value of weak (maybe edge) pixel\nstatic const int MIDDLE_VALUE = 150;\n// value of definitely not-edge pixel\nstatic const int BOTTOM_VALUE = 0;\n\n// Example how to detect edges via Canny algorithm\n// Read more about Canny edge detection algorithm on\n// https://docs.opencv.org/3.1.0/da/d22/tutorial_py_canny.html\n\ntemplate \nvoid gaussian_blur(const SrcView &src)\n{\n //1-D Gaussian blur kernel with kernel size 5, Sigma 1.0\n float gaussian[] = {0.06136f, 0.24477f, 0.38774f, 0.24477f, 0.06136f};\n kernel_1d kernel(gaussian, 5, 2);\n\n convolve_rows(src, kernel, src, convolve_option_output_ignore);\n convolve_cols(src, kernel, src, convolve_option_output_ignore);\n}\n\n// Function calculates image gradient (intensity and direction)\n// Smoothened image is filtered with a Sobel kernels in both horizontal and vertical\n// direction to get first derivative in horizontal direction (Gx) and vertical direction (Gy).\n// Gradient manitude is found as G = sqrt(Gx^2 + Gy^2)\n// Direction is found as angle = arctan(Gy / Gx)\n// More information about sobel filtering on https://en.wikipedia.org/wiki/Sobel_operator\nvoid sobel_filtering(const gray8c_view_t &src,\n const gray8_view_t &magnitude, const gray32f_view_t &slope)\n{\n // This we used 1-D convolution\n // Gx = second * (first * img)\n // Gy = first * (second * img)\n // where * is convolution\n float first_sobel[] = {1.f, 0.f, -1.f};\n float second_sobel[] = {1.f, 2.f, 1.f};\n\n kernel_1d first_sobel_kernel(first_sobel, 3, 1);\n kernel_1d second_sobel_kernel(second_sobel, 3, 1);\n\n //16 bits signed matrix is used in order to avoid char overflow\n gray16s_image_t vertical(src.dimensions());\n gray16s_image_t horizontal(src.dimensions());\n\n convolve_rows(src, first_sobel_kernel,\n view(vertical), convolve_option_output_zero);\n convolve_cols(const_view(vertical), second_sobel_kernel,\n view(vertical), convolve_option_output_zero);\n\n convolve_rows(src, second_sobel_kernel, view(horizontal),\n convolve_option_output_zero);\n convolve_cols(const_view(horizontal), first_sobel_kernel,\n view(horizontal), convolve_option_output_zero);\n\n // Magnitude and angle calculation\n auto ver_it = view(vertical).begin();\n auto hor_it = view(horizontal).begin();\n auto slope_it = slope.begin();\n\n for (auto mag_it = magnitude.begin(); mag_it != magnitude.end();\n ++mag_it, ++ver_it, ++hor_it, ++slope_it) {\n\n // std::min was used to be sure, that pixel max value less than 256\n *mag_it = std::min(UINT8_MAX,\n (int)std::sqrt(\n std::pow((int)(*ver_it), 2) + std::pow((int)(*hor_it), 2)));\n\n *slope_it = (float)std::atan2((int)(*hor_it), (int)(*ver_it));\n }\n}\n\n// Non-maximum suppression method is perfomed to thin out edges of the image\n// Method goes throug all the points on the gradient intensity matrix and\n// finds the pixels with maximum value in the edge direction\nvoid non_maximal_suppression(const gray8c_view_t &magnitude, const gray32fc_view_t &angle,\n const gray8_view_t &dst)\n{\n // Dst matrix fills with 0\n fill_pixels(dst, int8_t(0));\n\n auto mag_loc = magnitude.xy_at(1, 1);\n int q, r;\n int index;\n int curVal;\n for (int y = 1; y < magnitude.height() - 1; ++y) {\n auto dst_it = dst.row_begin(y);\n auto angle_it = angle.row_begin(y);\n\n for (int x = 1; x < dst.width() - 1; ++x, ++angle_it, ++dst_it, ++mag_loc.x()) {\n // Index helps to find direction of the edge\n // Pixel has 8 neighbors and 4 possible directions\n // (-1,-1) (0,-1) (1,-1)\n // (-1, 0) (0, 0) (1, 0)\n // (-1, 1) (0, 1) (1, 1)\n // On each direction 2 possible neighbors\n // If both of them is smaller than current value (0, 0),\n // then current value is saved in output image\n index = (int)((*angle_it)[0] * 8 / M_PI);\n index = (index < 0) ? index + 8 : index;\n\n curVal = mag_loc(0, 0);\n\n switch (index) {\n // Horizontal direction\n case 0:\n case 7:\n case 8:\n q = mag_loc(1, 0);\n r = mag_loc(-1, 0);\n break;\n // 45 degree\n case 1:\n case 2:\n q = mag_loc(1, 1);\n r = mag_loc(-1, -1);\n break;\n // Vertical direction\n case 3:\n case 4:\n q = mag_loc(0, 1);\n r = mag_loc(0, -1);\n break;\n // 135 degree\n case 5:\n case 6:\n q = mag_loc(1, -1);\n r = mag_loc(-1, 1);\n break;\n }\n\n if ((curVal >= q) && (curVal >= r)) {\n *dst_it = curVal;\n }\n }\n mag_loc += point2(-dst.width() + 2, 1);\n }\n}\n\nvoid hysteresis_threshold(const gray8_view_t &dst, int minVal, int maxVal)\n{\n // Histogram calculation of 3 groups: strong pixel, weak pixel, definitely not-edge pixel\n for_each_pixel(dst, [minVal, maxVal](gray8_pixel_t &pixel) {\n pixel = (pixel < minVal) ? BOTTOM_VALUE :\n ((pixel > maxVal) ? TOP_VALUE : MIDDLE_VALUE);\n });\n\n // Weak pixels check\n // If weak pixel has a strong neighbor, then it is strong one\n // otherwise it is definitely not-edge pixel\n auto dst_loc = dst.xy_at(1, 1);\n for (int i = 1; i < dst.height() - 1; ++i) {\n for (int j = 1; j < dst.width() - 1; ++j, ++dst_loc.x()) {\n if (dst_loc(0, 0) == MIDDLE_VALUE) {\n if (dst_loc(-1, -1) == TOP_VALUE || dst_loc(-1, 0) == TOP_VALUE ||\n dst_loc(-1, 1) == TOP_VALUE || dst_loc(1, -1) == TOP_VALUE ||\n dst_loc(1, 0) == TOP_VALUE || dst_loc(1, 1) == TOP_VALUE ||\n dst_loc(0, -1) == TOP_VALUE || dst_loc(0, 1) == TOP_VALUE)\n dst_loc(0, 0) = TOP_VALUE;\n else\n dst_loc(0, 0) = BOTTOM_VALUE;\n }\n }\n dst_loc += point2(-dst.width() + 2, 1);\n }\n}\n\nvoid canny_edge_detection(const rgb8c_view_t &src,\n const gray8_view_t &dst, int minVal, int maxVal)\n{\n // Canny edge detection algorithm works on grayscale images only\n gray8_image_t gray_img(src.dimensions());\n copy_pixels(color_converted_view(src), view(gray_img));\n\n gaussian_blur(view(gray_img));\n\n gray32f_image_t angle(src.dimensions());\n gray8_image_t magnitude(src.dimensions());\n sobel_filtering(view(gray_img), view(magnitude), view(angle));\n\n non_maximal_suppression(view(magnitude), view(angle), dst);\n\n hysteresis_threshold(dst, minVal, maxVal);\n}\n\nint main(int argc, char *argv[])\n{\n char *input = \"test.jpg\";\n char *output = \"canny.jpg\";\n int min_threshold_value = 30;\n int max_threshold_value = 70;\n\n if (argc >= 2 && (argv[1][0] == '-') && (argv[1][1] == 'H' || argv[1][1] == 'h')) {\n printf(\"canny [path_to_input [path_to_output \"\n \"[min_threshold_value [max_threshold_value]]]]\\n\");\n return 0;\n }\n if (argc >= 2) input = argv[1];\n if (argc >= 3) output = argv[2];\n if (argc >= 4) min_threshold_value = atoi(argv[3]);\n if (argc >= 5) max_threshold_value = atoi(argv[4]);\n\n if (min_threshold_value > max_threshold_value)\n std::swap(min_threshold_value, max_threshold_value);\n\n rgb8_image_t img;\n read_image(input, img, jpeg_tag{});\n\n gray8_image_t res_img(img.dimensions());\n canny_edge_detection(const_view(img), view(res_img),\n min_threshold_value, max_threshold_value);\n write_view(output, view(res_img), jpeg_tag{});\n return 0;\n}\n", "meta": {"hexsha": "1f8af033ffa006bc4536d6563b6978a70440f445", "size": 8534, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "example/canny.cpp", "max_stars_repo_name": "Antropovi/gil", "max_stars_repo_head_hexsha": "1f67b483956e655a391906a1c84f40572d2d8403", "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": "example/canny.cpp", "max_issues_repo_name": "Antropovi/gil", "max_issues_repo_head_hexsha": "1f67b483956e655a391906a1c84f40572d2d8403", "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": "example/canny.cpp", "max_forks_repo_name": "Antropovi/gil", "max_forks_repo_head_hexsha": "1f67b483956e655a391906a1c84f40572d2d8403", "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": 37.5947136564, "max_line_length": 94, "alphanum_fraction": 0.5925708929, "num_tokens": 2283, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7248702880639791, "lm_q2_score": 0.6893056104028799, "lm_q1q2_score": 0.4996571563768525}} {"text": "/**\n * @file\n * @brief Solution of source-free heat equation and computation of H1\n * \t seminorms on different triangular meshes and refinement levels\n * @author Julien Gacon, Amélie Loher\n * @date March 2019\n */\n\n#include \"unstablebvp.h\"\n// General includes\n#include \n#include \n#include \n#include \n// Eigen\n#include \n#include \n// Lehrfempp\n#include \n#include \n#include \n#include \n#include \n\nnamespace UnstableBVP {\n\nstd::shared_ptr createMeshHierarchy(\n const int reflevels, const std::string &mesh_type) {\n // Helper object: mesh factory\n std::shared_ptr mesh_factory_ptr =\n std::make_shared(2);\n\n // Decide where the triangular domain should be located in x_2 direction\n // by adding an offset to the x_2 coordinate of the nodes\n double offset = 0;\n if (mesh_type == \"top\") {\n offset = 1.5;\n } else if (mesh_type == \"bottom\") {\n offset = -1.5;\n } else {\n // already at 0\n }\n\n // Define the nodes\n std::array, 3> node_coord{\n std::array({0.5, -0.5 + offset}),\n std::array({0, 0.5 + offset}),\n std::array({1, 0.5 + offset})};\n\n for (const auto &node : node_coord) {\n mesh_factory_ptr->AddPoint(Eigen::Vector2d({node[0], node[1]}));\n }\n\n // Initialize triangle\n mesh_factory_ptr->AddEntity(lf::base::RefEl::kTria(),\n std::vector({0, 1, 2}),\n std::unique_ptr(nullptr));\n\n // Get a pointer to the mesh\n std::shared_ptr mesh_p = mesh_factory_ptr->Build();\n\n // (optional) Print information about the mesh\n // std::cout << \" Mesh info\\n\" << *mesh_p;\n\n // Ask LehrFEM++ to create a hierarchy of nested meshes\n std::shared_ptr multi_mesh_p =\n lf::refinement::GenerateMeshHierarchyByUniformRefinemnt(mesh_p,\n reflevels);\n\n return multi_mesh_p;\n}\n\ndouble solveTemperatureDistribution(\n std::shared_ptr mesh_p) {\n // **********************************************************************\n // Stage 0: provide all coefficient functions mainly through lambda\n // functions and derived MeshFunctions\n // **********************************************************************\n\n // The boundary condition\n auto bc = [](Eigen::Vector2d x) -> double {\n return x[1] <= 0 ? 1 - x[1] : 0;\n };\n // Wrap into a MeshFunction\n lf::mesh::utils::MeshFunctionGlobal mf_bc{bc};\n\n // We use lowest-order (p.w. linear Lagrangian finite elements), for which\n // LehrFEM++ provides a built-in description according to the paradigm of\n // parametric finite elements.\n auto fe_space =\n std::make_shared>(mesh_p);\n // Reference to current mesh\n const lf::mesh::Mesh &mesh{*(fe_space->Mesh())};\n // Obtain local->global index mapping for current finite element space\n const lf::assemble::DofHandler &dofh{fe_space->LocGlobMap()};\n\n // **********************************************************************\n // Stage 1: Assemble finite element Galerkin matrix\n // **********************************************************************\n\n // Dimension of finite element space`\n const lf::base::size_type N_dofs(dofh.NumDofs());\n // Matrix in triplet format holding Galerkin matrix, zero initially.\n lf::assemble::COOMatrix A(N_dofs, N_dofs);\n\n // Element matrix builder for the negative Laplacian\n lf::uscalfe::LinearFELaplaceElementMatrix elmat_builder{};\n\n // Invoke assembly on cells (co-dimension = 0 as first argument)\n // Information about the mesh and the local-to-global map is passed through\n // a Dofhandler object, argument 'dofh'. This function call adds triplets to\n // the internal COO-format representation of the sparse matrix A.\n lf::assemble::AssembleMatrixLocally(0, dofh, dofh, elmat_builder, A);\n\n // **********************************************************************\n // Stage 2: Right-hand side vector\n // **********************************************************************\n\n // Define RHS vector\n // No source, hence it is simply zero\n Eigen::Matrix phi(N_dofs);\n phi.setZero();\n\n // **********************************************************************\n // Stage 3: Fixing solution components according to essential (Dirichlet)\n // boundary conditions\n // **********************************************************************\n\n // Obtain specification for shape functions on edges\n std::shared_ptr>\n rsf_edge_p = fe_space->ShapeFunctionLayout(lf::base::RefEl::kSegment());\n LF_ASSERT_MSG(rsf_edge_p != nullptr, \"FE specification for edges missing\");\n\n // Obtain an array of boolean flags for the edges (codim 1) of the mesh,\n // `true` indicates that the edge lies on the boundary\n auto bd_flags{lf::mesh::utils::flagEntitiesOnBoundary(fe_space->Mesh(), 1)};\n\n // Fetch flags and values for degrees of freedom located on Dirichlet\n // edges.\n auto ess_bdc_flags_values{lf::uscalfe::InitEssentialConditionFromFunction(\n dofh, *rsf_edge_p,\n [&bd_flags](const lf::mesh::Entity &edge) -> bool {\n return (bd_flags(edge));\n },\n mf_bc)};\n\n // Eliminate Dirichlet dofs from linear system\n lf::assemble::FixFlaggedSolutionComponents(\n [&ess_bdc_flags_values](lf::assemble::glb_idx_t gdof_idx) {\n return ess_bdc_flags_values[gdof_idx];\n },\n A, phi);\n\n // **********************************************************************\n // Stage 4: Solve LSE\n // **********************************************************************\n\n // Assembly completed: Convert COO matrix A into CRS format using Eigen's\n // internal conversion routines.\n Eigen::SparseMatrix A_crs = A.makeSparse();\n\n // Solve linear system using Eigen's sparse direct elimination\n Eigen::SparseLU> solver;\n solver.compute(A_crs);\n LF_VERIFY_MSG(solver.info() == Eigen::Success, \"LU decomposition failed\");\n Eigen::VectorXd sol_vec = solver.solve(phi);\n LF_VERIFY_MSG(solver.info() == Eigen::Success, \"Solving LSE failed\");\n\n // **********************************************************************\n // Stage 5: Compute H1 seminorm\n // **********************************************************************\n\n // Compute the difference to a function that's zero everywhere, hence\n // just the gradient of the solution (which is encapsulated in the fe_space).\n // We use this trick to avoid the manual computation and make use of the\n // LehrFEM facilities :)\n lf::uscalfe::MeshFunctionL2GradientDifference loc_comp(\n fe_space,\n lf::mesh::utils::MeshFunctionConstant(Eigen::Vector2d(0.0, 0.0)), 2);\n\n // Compute the norm of the ``difference'' (i.e. the norm of the gradient of\n // the solution)\n const double norm = lf::uscalfe::NormOfDifference(dofh, loc_comp, sol_vec);\n\n return norm;\n}\n\n} // namespace UnstableBVP\n", "meta": {"hexsha": "c93ac3118d2fed153b4301f0e1b34b6ba9e7ee89", "size": 7338, "ext": "cc", "lang": "C++", "max_stars_repo_path": "homeworks/UnstableBVP/templates/unstablebvp.cc", "max_stars_repo_name": "padomu/NPDECODES", "max_stars_repo_head_hexsha": "d2bc5b0d2d5e76e4d5b8ab6948c82f902211182e", "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": "homeworks/UnstableBVP/templates/unstablebvp.cc", "max_issues_repo_name": "padomu/NPDECODES", "max_issues_repo_head_hexsha": "d2bc5b0d2d5e76e4d5b8ab6948c82f902211182e", "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": "homeworks/UnstableBVP/templates/unstablebvp.cc", "max_forks_repo_name": "padomu/NPDECODES", "max_forks_repo_head_hexsha": "d2bc5b0d2d5e76e4d5b8ab6948c82f902211182e", "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": 38.8253968254, "max_line_length": 80, "alphanum_fraction": 0.6046606705, "num_tokens": 1786, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.689305616785446, "lm_q2_score": 0.7248702761768248, "lm_q1q2_score": 0.4996571528095028}} {"text": "#include \"sv/util/eigen.h\"\n\n#include \n\n#include \"sv/util/logging.h\"\n\nnamespace sv {\n\nvoid StableRotateBlockTopLeft(MatrixXdRef H,\n VectorXdRef b,\n int block_ind,\n int block_size) {\n CHECK_EQ(H.rows(), b.size());\n CHECK_EQ(H.cols(), b.size());\n CHECK_GE(block_ind, 0);\n CHECK_GT(block_size, 0);\n CHECK_LT(block_ind * block_size, H.rows());\n\n if (block_ind == 0) return;\n const auto n = block_size;\n\n // Permute block of rows up gradually, also need to permute b\n for (int i = block_ind; i > 0; --i) {\n const auto r = i * block_size;\n // swap current rows with above rows\n H.middleRows(r, n).swap(H.middleRows(r - n, n));\n b.segment(r, n).swap(b.segment(r - n, n));\n }\n\n // Permute block of cols\n for (int j = block_ind; j > 0; --j) {\n const auto c = j * block_size;\n // swap current cols with left cols\n H.middleCols(c, n).swap(H.middleCols(c - n, n));\n }\n}\n\nvoid FillLowerTriangular(MatrixXdRef M) {\n CHECK_EQ(M.rows(), M.cols());\n M.triangularView() =\n M.triangularView().transpose();\n}\n\nvoid FillUpperTriangular(MatrixXdRef M) {\n CHECK_EQ(M.rows(), M.cols());\n M.triangularView() =\n M.triangularView().transpose();\n}\n\nvoid MakeSymmetric(MatrixXdRef M) {\n CHECK_EQ(M.rows(), M.cols());\n M += M.transpose().eval();\n M.array() /= 2.0;\n}\n\nvoid MargTopLeftBlock(const MatrixXdCRef& Hf,\n const VectorXdCRef& bf,\n MatrixXdRef Hm,\n VectorXdRef bm,\n int dim) {\n // Pre-condition\n // 1. Hf is square and match bsc and symmetric\n // 2. Hm is quare and match bpr\n const auto nf = bf.size();\n const auto nm = bm.size();\n CHECK_GT(dim, 0);\n CHECK_EQ(nm + dim, nf);\n CHECK_EQ(Hf.rows(), nf);\n CHECK_EQ(Hf.cols(), nf);\n CHECK_EQ(Hm.rows(), nm);\n CHECK_EQ(Hm.cols(), nm);\n CHECK_EQ(Hf, Hf.transpose()) << \"\\n\" << Hf;\n\n // Hf bf\n // [ H00 H01 ] [ x0 ] = [ b0 ]\n // [ H10 H11 ] [ x1 ] = [ b1 ]\n // Hm = H11 - H10 * H00^-1 * H01\n // bm = b1 - H10 * H00^-1 * b0\n const auto H01 = Hf.topRightCorner(dim, nm);\n const auto H10 = Hf.bottomLeftCorner(nm, dim);\n\n // Benchmark shows that simply inverse has similar speed as llt\n // However to account for rank-deficiency we use ldlt to inverse\n const auto H00_inv = Hf.topLeftCorner(dim, dim)\n .selfadjointView()\n .ldlt()\n .solve(Eigen::MatrixXd::Identity(dim, dim))\n .eval();\n\n Hm = Hf.bottomRightCorner(nm, nm);\n Hm.noalias() -= H10 * H00_inv * H01;\n\n const auto b0 = bf.head(dim);\n bm = bf.tail(nm); // b1\n bm.noalias() -= H10 * (H00_inv * b0);\n\n // Make sure Hpr is symmetric\n MakeSymmetric(Hm);\n\n // Post-condition\n // 1. Hpr shape doesn't change\n // 2. Hpr is symmetric\n CHECK_EQ(Hm.rows(), nm);\n CHECK_EQ(Hm.cols(), nm);\n CHECK_EQ(Hm, Hm.transpose()) << \"\\n\" << Hm;\n}\n\n} // namespace sv\n", "meta": {"hexsha": "1f8425fc30c595100b03e6d18dd4f8fe4e7608d0", "size": 3089, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "sv/util/eigen.cpp", "max_stars_repo_name": "versatran01/dsol", "max_stars_repo_head_hexsha": "1c390f10f55fed0d0ef62b0f18e9003bd82c3876", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 52.0, "max_stars_repo_stars_event_min_datetime": "2022-03-17T02:03:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T06:11:52.000Z", "max_issues_repo_path": "sv/util/eigen.cpp", "max_issues_repo_name": "versatran01/dsol", "max_issues_repo_head_hexsha": "1c390f10f55fed0d0ef62b0f18e9003bd82c3876", "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": "sv/util/eigen.cpp", "max_forks_repo_name": "versatran01/dsol", "max_forks_repo_head_hexsha": "1c390f10f55fed0d0ef62b0f18e9003bd82c3876", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2022-03-17T06:13:06.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T09:15:58.000Z", "avg_line_length": 28.3394495413, "max_line_length": 70, "alphanum_fraction": 0.5681450308, "num_tokens": 918, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7248702761768248, "lm_q2_score": 0.6893056040203135, "lm_q1q2_score": 0.49965714355643764}} {"text": "/*\n * Copyright (c) 2013-2015 Masahide Kashiwagi (kashi@waseda.jp)\n */\n\n#ifndef NEWTON_HPP\n#define NEWTON_HPP\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\nnamespace kv {\n\nnamespace ub = boost::numeric::ublas;\n\n\ntemplate \nbool\nnewton(F f, ub::vector& x, T epsilon = std::numeric_limits::epsilon(), int maxloop = 100)\n{\n\tint s = x.size();\n\tint i, j, r;\n\tub::vector fx;\n\tub::matrix fdx;\n\tT norm1, norm2;\n\n\tfor (i=0; i::split(f(autodif::init(x)), fx, fdx);\n\t\t\tub::permutation_matrix<> pm(s);\n\t\t\tr = ub::lu_factorize(fdx, pm);\n\t\t\tif (r != 0) return false;\n\t\t\tub::lu_substitute(fdx, pm, fx);\n\t\t}\n\t\tcatch (...) {\n\t\t\treturn false;\n\t\t}\n\n\t\tnorm1 = 1.;\n\t\tnorm2 = 0.;\n\t\tfor (j=0; j\nbool\nnewton_random(F f, ub::vector& x, T epsilon = std::numeric_limits::epsilon(), int maxloop = 100)\n{\n\tint s = x.size();\n\tint i;\n\n\tusing namespace boost;\n\t// use \"static\" to be \"randomized\" only once\n\tstatic variate_generator< mt19937, normal_distribution<> > rand (mt19937(time(0)), normal_distribution<>(0., 10.));\n\n\tfor (i=0; i\n * @ingroup aux_tracking\n */\n\n#pragma once\n\n#ifndef __cplusplus\n#error \"This header is C++-only.\"\n#endif\n\n#include \n#include \n\n#include \"flexkalman/AugmentedProcessModel.h\"\n#include \"flexkalman/AugmentedState.h\"\n#include \"flexkalman/BaseTypes.h\"\n#include \"flexkalman/PoseState.h\"\n\n\nnamespace xrt::auxiliary::tracking {\n\nnamespace types = flexkalman::types;\nusing flexkalman::types::Vector;\n\n//! For things like accelerometers, which on some level measure the local vector\n//! of a world direction.\ntemplate \nclass WorldDirectionMeasurement : public flexkalman::MeasurementBase>\n{\npublic:\n\tEIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\tstatic constexpr size_t Dimension = 3;\n\tusing MeasurementVector = types::Vector;\n\tusing MeasurementSquareMatrix = types::SquareMatrix;\n\tWorldDirectionMeasurement(types::Vector<3> const &direction,\n\t types::Vector<3> const &reference,\n\t types::Vector<3> const &variance)\n\t : direction_(direction.normalized()), reference_(reference.normalized()), covariance_(variance.asDiagonal())\n\t{}\n\n\tMeasurementSquareMatrix const &\n\tgetCovariance(State const & /*s*/)\n\t{\n\t\treturn covariance_;\n\t}\n\n\ttypes::Vector<3>\n\tpredictMeasurement(State const &s) const\n\t{\n\t\treturn s.getCombinedQuaternion() * reference_;\n\t}\n\n\tMeasurementVector\n\tgetResidual(MeasurementVector const &predictedMeasurement, State const &s) const\n\t{\n\t\treturn predictedMeasurement - reference_;\n\t}\n\n\tMeasurementVector\n\tgetResidual(State const &s) const\n\t{\n\t\treturn getResidual(predictMeasurement(s), s);\n\t}\n\nprivate:\n\ttypes::Vector<3> direction_;\n\ttypes::Vector<3> reference_;\n\tMeasurementSquareMatrix covariance_;\n};\n#if 0\n//! For things like accelerometers, which on some level measure the local vector\n//! of a world direction.\nclass LinAccelWithGravityMeasurement\n : public flexkalman::MeasurementBase\n{\npublic:\n\tEIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\tstatic constexpr size_t Dimension = 3;\n\tusing MeasurementVector = types::Vector;\n\tusing MeasurementSquareMatrix = types::SquareMatrix;\n\tLinAccelWithGravityMeasurement(types::Vector<3> const &direction,\n\t types::Vector<3> const &reference,\n\t types::Vector<3> const &variance)\n\t : direction_(direction), reference_(reference),\n\t covariance_(variance.asDiagonal())\n\t{}\n\n\t// template \n\tMeasurementSquareMatrix const &\n\tgetCovariance(State const & /*s*/)\n\t{\n\t\treturn covariance_;\n\t}\n\n\t// template \n\ttypes::Vector<3>\n\tpredictMeasurement(State const &s) const\n\t{\n\t\treturn reference_;\n\t}\n\n\t// template \n\tMeasurementVector\n\tgetResidual(MeasurementVector const &predictedMeasurement,\n\t State const &s) const\n\t{\n\t\ts.getQuaternion().conjugate() *\n\t\t predictedMeasurement return predictedMeasurement -\n\t\t reference_.normalized();\n\t}\n\n\ttemplate \n\tMeasurementVector\n\tgetResidual(State const &s) const\n\t{\n\t\tMeasurementVector residual =\n\t\t direction_ - reference_ * s.getQuaternion();\n\t\treturn getResidual(predictMeasurement(s), s);\n\t}\n\nprivate:\n\ttypes::Vector<3> direction_;\n\ttypes::Vector<3> reference_;\n\tMeasurementSquareMatrix covariance_;\n};\n#endif\n\nclass BiasedGyroMeasurement : public flexkalman::MeasurementBase\n{\npublic:\n\tEIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\tstatic constexpr size_t Dimension = 3;\n\tusing MeasurementVector = types::Vector;\n\tusing MeasurementSquareMatrix = types::SquareMatrix;\n\tBiasedGyroMeasurement(types::Vector<3> const &angVel, types::Vector<3> const &variance)\n\t : angVel_(angVel), covariance_(variance.asDiagonal())\n\t{}\n\n\ttemplate \n\tMeasurementSquareMatrix const &\n\tgetCovariance(State const & /*s*/)\n\t{\n\t\treturn covariance_;\n\t}\n\n\ttemplate \n\ttypes::Vector<3>\n\tpredictMeasurement(State const &s) const\n\t{\n\t\treturn s.b().stateVector() + angVel_;\n\t}\n\n\ttemplate \n\tMeasurementVector\n\tgetResidual(MeasurementVector const &predictedMeasurement, State const &s) const\n\t{\n\t\treturn predictedMeasurement - s.a().angularVelocity();\n\t}\n\n\ttemplate \n\tMeasurementVector\n\tgetResidual(State const &s) const\n\t{\n\t\treturn getResidual(predictMeasurement(s), s);\n\t}\n\nprivate:\n\ttypes::Vector<3> angVel_;\n\tMeasurementSquareMatrix covariance_;\n};\n/*!\n * For PS Move-like things, where there's a directly-computed absolute position\n * that is not at the tracked body's origin.\n */\nclass AbsolutePositionLeverArmMeasurement : public flexkalman::MeasurementBase\n{\npublic:\n\tEIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\tusing State = flexkalman::pose_externalized_rotation::State;\n\tstatic constexpr size_t Dimension = 3;\n\tusing MeasurementVector = types::Vector;\n\tusing MeasurementSquareMatrix = types::SquareMatrix;\n\n\t/*!\n\t * @todo the point we get from the camera isn't the center of the ball,\n\t * but the center of the visible surface of the ball - a closer\n\t * approximation would be translation along the vector to the center of\n\t * projection....\n\t */\n\tAbsolutePositionLeverArmMeasurement(MeasurementVector const &measurement,\n\t MeasurementVector const &knownLocationInBodySpace,\n\t MeasurementVector const &variance)\n\t : measurement_(measurement), knownLocationInBodySpace_(knownLocationInBodySpace),\n\t covariance_(variance.asDiagonal())\n\t{}\n\n\tMeasurementSquareMatrix const &\n\tgetCovariance(State const & /*s*/)\n\t{\n\t\treturn covariance_;\n\t}\n\n\ttypes::Vector<3>\n\tpredictMeasurement(State const &s) const\n\t{\n\t\treturn s.getIsometry() * knownLocationInBodySpace_;\n\t}\n\n\tMeasurementVector\n\tgetResidual(MeasurementVector const &predictedMeasurement, State const & /*s*/) const\n\t{\n\t\treturn measurement_ - predictedMeasurement;\n\t}\n\n\tMeasurementVector\n\tgetResidual(State const &s) const\n\t{\n\t\treturn getResidual(predictMeasurement(s), s);\n\t}\n\nprivate:\n\tMeasurementVector measurement_;\n\tMeasurementVector knownLocationInBodySpace_;\n\tMeasurementSquareMatrix covariance_;\n};\n\n} // namespace xrt::auxiliary::tracking\n", "meta": {"hexsha": "ffb9c9e0f1d8ad7de045fccc762950fb92aa1689", "size": 6403, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/xrt/auxiliary/tracking/t_fusion.hpp", "max_stars_repo_name": "leviathanch/monado", "max_stars_repo_head_hexsha": "36a540a764fd5529018dfceb28e10804db9596bf", "max_stars_repo_licenses": ["Unlicense", "Apache-2.0", "BSD-2-Clause", "MIT", "BSL-1.0", "BSD-3-Clause"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-11-08T05:17:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-24T12:50:59.000Z", "max_issues_repo_path": "src/xrt/auxiliary/tracking/t_fusion.hpp", "max_issues_repo_name": "SimulaVR/monado", "max_issues_repo_head_hexsha": "b5d46eebf5f9b7f96a52639484a1b35d8ab3cd21", "max_issues_repo_licenses": ["Unlicense", "Apache-2.0", "BSD-2-Clause", "MIT", "BSL-1.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": "src/xrt/auxiliary/tracking/t_fusion.hpp", "max_forks_repo_name": "SimulaVR/monado", "max_forks_repo_head_hexsha": "b5d46eebf5f9b7f96a52639484a1b35d8ab3cd21", "max_forks_repo_licenses": ["Unlicense", "Apache-2.0", "BSD-2-Clause", "MIT", "BSL-1.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": 27.4806866953, "max_line_length": 115, "alphanum_fraction": 0.7441824145, "num_tokens": 1468, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.85391273808085, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.49962532863994674}} {"text": "/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */\n\n/*\n Copyright (C) 2006, 2007, 2015 Ferdinando Ametrano\n Copyright (C) 2006 Cristina Duminuco\n Copyright (C) 2007 Giorgio Facchinetti\n Copyright (C) 2015 Paolo Mazzocchi\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#ifndef quantlib_abcdcalibration_hpp\n#define quantlib_abcdcalibration_hpp\n\n\n#include \n#include \n#include \n\n#include \n\n#include \n\n\nnamespace QuantLib {\n \n class Quote;\n class OptimizationMethod;\n class ParametersTransformation;\n\n class AbcdCalibration {\n private:\n class AbcdError : public CostFunction {\n public:\n AbcdError(AbcdCalibration* abcd) : abcd_(abcd) {}\n\n Real value(const Array& x) const {\n const Array y = abcd_->transformation_->direct(x);\n abcd_->a_ = y[0];\n abcd_->b_ = y[1];\n abcd_->c_ = y[2];\n abcd_->d_ = y[3];\n return abcd_->error();\n }\n Disposable values(const Array& x) const {\n const Array y = abcd_->transformation_->direct(x);\n abcd_->a_ = y[0];\n abcd_->b_ = y[1];\n abcd_->c_ = y[2];\n abcd_->d_ = y[3];\n return abcd_->errors();\n }\n private:\n AbcdCalibration* abcd_;\n };\n\n class AbcdParametersTransformation : public ParametersTransformation {\n public:\n AbcdParametersTransformation() : y_(Array(4)) {}\n // to constrained <- from unconstrained\n Array direct(const Array& x) const;\n // to unconstrained <- from constrained\n Array inverse(const Array& x) const;\n private:\n mutable Array y_;\n };\n\n public:\n AbcdCalibration() {};\n AbcdCalibration(\n const std::vector& t,\n const std::vector& blackVols,\n Real aGuess = -0.06,\n Real bGuess = 0.17,\n Real cGuess = 0.54,\n Real dGuess = 0.17,\n bool aIsFixed = false,\n bool bIsFixed = false,\n bool cIsFixed = false,\n bool dIsFixed = false,\n bool vegaWeighted = false,\n const boost::shared_ptr& endCriteria\n = boost::shared_ptr(),\n const boost::shared_ptr& method\n = boost::shared_ptr());\n //! adjustment factors needed to match Black vols\n std::vector k(const std::vector& t,\n const std::vector& blackVols) const;\n void compute();\n //calibration results\n Real value(Real x) const;\n Real error() const;\n Real maxError() const;\n Disposable errors() const;\n EndCriteria::Type endCriteria() const;\n Real a() const { return a_; }\n Real b() const { return b_; }\n Real c() const { return c_; }\n Real d() const { return d_; }\n bool aIsFixed_, bIsFixed_, cIsFixed_, dIsFixed_;\n Real a_, b_, c_, d_;\n boost::shared_ptr transformation_;\n private:\n // optimization method used for fitting\n mutable EndCriteria::Type abcdEndCriteria_;\n boost::shared_ptr endCriteria_;\n boost::shared_ptr optMethod_;\n mutable std::vector weights_;\n bool vegaWeighted_;\n //! Parameters\n std::vector times_, blackVols_;\n };\n\n}\n\n/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */\n\n/*\n Copyright (C) 2006, 2015 Ferdinando Ametrano\n Copyright (C) 2006 Cristina Duminuco\n Copyright (C) 2005, 2006 Klaus Spanderen\n Copyright (C) 2007 Giorgio Facchinetti\n Copyright (C) 2015 Paolo Mazzocchi\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#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace QuantLib {\n\n // to constrained <- from unconstrained\n inline Array AbcdCalibration::AbcdParametersTransformation::direct(const Array& x) const {\n y_[1] = x[1];\n y_[2] = std::exp(x[2]);\n y_[3] = std::exp(x[3]);\n y_[0] = std::exp(x[0]) - y_[3];\n return y_;\n }\n\n // to unconstrained <- from constrained\n inline Array AbcdCalibration::AbcdParametersTransformation::inverse(const Array& x) const {\n y_[1] = x[1];\n y_[2] = std::log(x[2]);\n y_[3] = std::log(x[3]);\n y_[0] = std::log(x[0] + x[3]);\n return y_;\n }\n\n // to constrained <- from unconstrained\n\n inline AbcdCalibration::AbcdCalibration(\n const std::vector& t,\n const std::vector& blackVols,\n Real a, Real b, Real c, Real d,\n bool aIsFixed, bool bIsFixed, bool cIsFixed, bool dIsFixed,\n bool vegaWeighted,\n const boost::shared_ptr& endCriteria,\n const boost::shared_ptr& optMethod)\n : aIsFixed_(aIsFixed), bIsFixed_(bIsFixed),\n cIsFixed_(cIsFixed), dIsFixed_(dIsFixed),\n a_(a), b_(b), c_(c), d_(d),\n abcdEndCriteria_(EndCriteria::None), endCriteria_(endCriteria),\n optMethod_(optMethod), weights_(blackVols.size(), 1.0/blackVols.size()),\n vegaWeighted_(vegaWeighted),\n times_(t), blackVols_(blackVols) {\n\n AbcdMathFunction::validate(a, b, c, d);\n\n QL_REQUIRE(blackVols.size()==t.size(),\n \"mismatch between number of times (\" << t.size() <<\n \") and blackVols (\" << blackVols.size() << \")\");\n\n // if no optimization method or endCriteria is provided, we provide one\n if (!optMethod_) {\n Real epsfcn = 1.0e-8;\n Real xtol = 1.0e-8;\n Real gtol = 1.0e-8;\n bool useCostFunctionsJacobian = false;\n optMethod_ = boost::shared_ptr(new\n LevenbergMarquardt(epsfcn, xtol, gtol, useCostFunctionsJacobian));\n }\n if (!endCriteria_) {\n Size maxIterations = 10000;\n Size maxStationaryStateIterations = 1000;\n Real rootEpsilon = 1.0e-8;\n Real functionEpsilon = 0.3e-4; // Why 0.3e-4 ?\n Real gradientNormEpsilon = 0.3e-4; // Why 0.3e-4 ?\n endCriteria_ = boost::shared_ptr(new\n EndCriteria(maxIterations, maxStationaryStateIterations,\n rootEpsilon, functionEpsilon, gradientNormEpsilon));\n }\n }\n\n inline void AbcdCalibration::compute() {\n if (vegaWeighted_) {\n Real weightsSum = 0.0;\n for (Size i=0; i(new\n AbcdParametersTransformation);\n\n Array guess(4);\n guess[0] = a_;\n guess[1] = b_;\n guess[2] = c_;\n guess[3] = d_;\n\n std::vector parameterAreFixed(4);\n parameterAreFixed[0] = aIsFixed_;\n parameterAreFixed[1] = bIsFixed_;\n parameterAreFixed[2] = cIsFixed_;\n parameterAreFixed[3] = dIsFixed_;\n\n Array inversedTransformatedGuess(transformation_->inverse(guess));\n\n ProjectedCostFunction projectedAbcdCostFunction(costFunction,\n inversedTransformatedGuess, parameterAreFixed);\n\n Array projectedGuess\n (projectedAbcdCostFunction.project(inversedTransformatedGuess));\n\n NoConstraint constraint;\n Problem problem(projectedAbcdCostFunction, constraint, projectedGuess);\n abcdEndCriteria_ = optMethod_->minimize(problem, *endCriteria_);\n Array projectedResult(problem.currentValue());\n Array transfResult(projectedAbcdCostFunction.include(projectedResult));\n\n Array result = transformation_->direct(transfResult);\n AbcdMathFunction::validate(a_, b_, c_, d_);\n a_ = result[0];\n b_ = result[1];\n c_ = result[2];\n d_ = result[3];\n\n }\n }\n\n inline Real AbcdCalibration::value(Real x) const {\n return abcdBlackVolatility(x,a_,b_,c_,d_);\n }\n\n inline std::vector AbcdCalibration::k(const std::vector& t,\n const std::vector& blackVols) const {\n QL_REQUIRE(blackVols.size()==t.size(),\n \"mismatch between number of times (\" << t.size() <<\n \") and blackVols (\" << blackVols.size() << \")\");\n std::vector k(t.size());\n for (Size i=0; i AbcdCalibration::errors() const {\n Array results(times_.size());\n for (Size i=0; i\r\n#endif\r\n#ifndef BOOST_MATH_LOG1P_INCLUDED\r\n# include \r\n#endif\r\n#include \r\n\r\n#ifdef BOOST_NO_STDC_NAMESPACE\r\nnamespace std{ using ::sqrt; using ::fabs; using ::acos; using ::asin; using ::atan; using ::atan2; }\r\n#endif\r\n\r\nnamespace boost{ namespace math{\r\n\r\ntemplate \r\ninline std::complex asin(const std::complex& z)\r\n{\r\n //\r\n // This implementation is a transcription of the pseudo-code in:\r\n //\r\n // \"Implementing the complex Arcsine and Arccosine Functions using Exception Handling.\"\r\n // T E Hull, Thomas F Fairgrieve and Ping Tak Peter Tang.\r\n // ACM Transactions on Mathematical Software, Vol 23, No 3, Sept 1997.\r\n //\r\n\r\n //\r\n // These static constants should really be in a maths constants library:\r\n //\r\n static const T one = static_cast(1);\r\n //static const T two = static_cast(2);\r\n static const T half = static_cast(0.5L);\r\n static const T a_crossover = static_cast(1.5L);\r\n static const T b_crossover = static_cast(0.6417L);\r\n static const T s_pi = boost::math::constants::pi();\r\n static const T half_pi = s_pi / 2;\r\n static const T log_two = boost::math::constants::ln_two();\r\n static const T quarter_pi = s_pi / 4;\r\n#ifdef BOOST_MSVC\r\n#pragma warning(push)\r\n#pragma warning(disable:4127)\r\n#endif\r\n //\r\n // Get real and imaginary parts, discard the signs as we can \r\n // figure out the sign of the result later:\r\n //\r\n T x = std::fabs(z.real());\r\n T y = std::fabs(z.imag());\r\n T real, imag; // our results\r\n\r\n //\r\n // Begin by handling the special cases for infinities and nan's\r\n // specified in C99, most of this is handled by the regular logic\r\n // below, but handling it as a special case prevents overflow/underflow\r\n // arithmetic which may trip up some machines:\r\n //\r\n if((boost::math::isnan)(x))\r\n {\r\n if((boost::math::isnan)(y))\r\n return std::complex(x, x);\r\n if((boost::math::isinf)(y))\r\n {\r\n real = x;\r\n imag = std::numeric_limits::infinity();\r\n }\r\n else\r\n return std::complex(x, x);\r\n }\r\n else if((boost::math::isnan)(y))\r\n {\r\n if(x == 0)\r\n {\r\n real = 0;\r\n imag = y;\r\n }\r\n else if((boost::math::isinf)(x))\r\n {\r\n real = y;\r\n imag = std::numeric_limits::infinity();\r\n }\r\n else\r\n return std::complex(y, y);\r\n }\r\n else if((boost::math::isinf)(x))\r\n {\r\n if((boost::math::isinf)(y))\r\n {\r\n real = quarter_pi;\r\n imag = std::numeric_limits::infinity();\r\n }\r\n else\r\n {\r\n real = half_pi;\r\n imag = std::numeric_limits::infinity();\r\n }\r\n }\r\n else if((boost::math::isinf)(y))\r\n {\r\n real = 0;\r\n imag = std::numeric_limits::infinity();\r\n }\r\n else\r\n {\r\n //\r\n // special case for real numbers:\r\n //\r\n if((y == 0) && (x <= one))\r\n return std::complex(std::asin(z.real()), z.imag());\r\n //\r\n // Figure out if our input is within the \"safe area\" identified by Hull et al.\r\n // This would be more efficient with portable floating point exception handling;\r\n // fortunately the quantities M and u identified by Hull et al (figure 3), \r\n // match with the max and min methods of numeric_limits.\r\n //\r\n T safe_max = detail::safe_max(static_cast(8));\r\n T safe_min = detail::safe_min(static_cast(4));\r\n\r\n T xp1 = one + x;\r\n T xm1 = x - one;\r\n\r\n if((x < safe_max) && (x > safe_min) && (y < safe_max) && (y > safe_min))\r\n {\r\n T yy = y * y;\r\n T r = std::sqrt(xp1*xp1 + yy);\r\n T s = std::sqrt(xm1*xm1 + yy);\r\n T a = half * (r + s);\r\n T b = x / a;\r\n\r\n if(b <= b_crossover)\r\n {\r\n real = std::asin(b);\r\n }\r\n else\r\n {\r\n T apx = a + x;\r\n if(x <= one)\r\n {\r\n real = std::atan(x/std::sqrt(half * apx * (yy /(r + xp1) + (s-xm1))));\r\n }\r\n else\r\n {\r\n real = std::atan(x/(y * std::sqrt(half * (apx/(r + xp1) + apx/(s+xm1)))));\r\n }\r\n }\r\n\r\n if(a <= a_crossover)\r\n {\r\n T am1;\r\n if(x < one)\r\n {\r\n am1 = half * (yy/(r + xp1) + yy/(s - xm1));\r\n }\r\n else\r\n {\r\n am1 = half * (yy/(r + xp1) + (s + xm1));\r\n }\r\n imag = boost::math::log1p(am1 + std::sqrt(am1 * (a + one)));\r\n }\r\n else\r\n {\r\n imag = std::log(a + std::sqrt(a*a - one));\r\n }\r\n }\r\n else\r\n {\r\n //\r\n // This is the Hull et al exception handling code from Fig 3 of their paper:\r\n //\r\n if(y <= (std::numeric_limits::epsilon() * std::fabs(xm1)))\r\n {\r\n if(x < one)\r\n {\r\n real = std::asin(x);\r\n imag = y / std::sqrt(-xp1*xm1);\r\n }\r\n else\r\n {\r\n real = half_pi;\r\n if(((std::numeric_limits::max)() / xp1) > xm1)\r\n {\r\n // xp1 * xm1 won't overflow:\r\n imag = boost::math::log1p(xm1 + std::sqrt(xp1*xm1));\r\n }\r\n else\r\n {\r\n imag = log_two + std::log(x);\r\n }\r\n }\r\n }\r\n else if(y <= safe_min)\r\n {\r\n // There is an assumption in Hull et al's analysis that\r\n // if we get here then x == 1. This is true for all \"good\"\r\n // machines where :\r\n // \r\n // E^2 > 8*sqrt(u); with:\r\n //\r\n // E = std::numeric_limits::epsilon()\r\n // u = (std::numeric_limits::min)()\r\n //\r\n // Hull et al provide alternative code for \"bad\" machines\r\n // but we have no way to test that here, so for now just assert\r\n // on the assumption:\r\n //\r\n BOOST_ASSERT(x == 1);\r\n real = half_pi - std::sqrt(y);\r\n imag = std::sqrt(y);\r\n }\r\n else if(std::numeric_limits::epsilon() * y - one >= x)\r\n {\r\n real = x/y; // This can underflow!\r\n imag = log_two + std::log(y);\r\n }\r\n else if(x > one)\r\n {\r\n real = std::atan(x/y);\r\n T xoy = x/y;\r\n imag = log_two + std::log(y) + half * boost::math::log1p(xoy*xoy);\r\n }\r\n else\r\n {\r\n T a = std::sqrt(one + y*y);\r\n real = x/a; // This can underflow!\r\n imag = half * boost::math::log1p(static_cast(2)*y*(y+a));\r\n }\r\n }\r\n }\r\n\r\n //\r\n // Finish off by working out the sign of the result:\r\n //\r\n if((boost::math::signbit)(z.real()))\r\n real = (boost::math::changesign)(real);\r\n if((boost::math::signbit)(z.imag()))\r\n imag = (boost::math::changesign)(imag);\r\n\r\n return std::complex(real, imag);\r\n#ifdef BOOST_MSVC\r\n#pragma warning(pop)\r\n#endif\r\n}\r\n\r\n} } // namespaces\r\n\r\n#endif // BOOST_MATH_COMPLEX_ASIN_INCLUDED\r\n", "meta": {"hexsha": "4b1e0f8ef04f9bbe1b7ceecdb43de02801a5b310", "size": 7606, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "master/core/third/boost/math/complex/asin.hpp", "max_stars_repo_name": "importlib/klib", "max_stars_repo_head_hexsha": "a59837857689d0e60d3df6d2ebd12c3160efa794", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 198.0, "max_stars_repo_stars_event_min_datetime": "2015-01-13T05:47:18.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T04:46:46.000Z", "max_issues_repo_path": "master/core/third/boost/math/complex/asin.hpp", "max_issues_repo_name": "isuhao/klib", "max_issues_repo_head_hexsha": "a59837857689d0e60d3df6d2ebd12c3160efa794", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 197.0, "max_issues_repo_issues_event_min_datetime": "2017-07-06T16:53:59.000Z", "max_issues_repo_issues_event_max_datetime": "2019-05-31T17:57:51.000Z", "max_forks_repo_path": "master/core/third/boost/math/complex/asin.hpp", "max_forks_repo_name": "isuhao/klib", "max_forks_repo_head_hexsha": "a59837857689d0e60d3df6d2ebd12c3160efa794", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 139.0, "max_forks_repo_forks_event_min_datetime": "2015-01-15T20:09:31.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-31T15:21:16.000Z", "avg_line_length": 30.1825396825, "max_line_length": 102, "alphanum_fraction": 0.4884301867, "num_tokens": 1945, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891392358015, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.4996140585502038}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace Eigen;\nusing namespace cv;\n\ntypedef vector> VecVector2d;\n\n// Camera intrinsics\n// 内参\ndouble fx = 718.856, fy = 718.856, cx = 607.1928, cy = 185.2157;\n// 基线\ndouble baseline = 0.573;\n// paths\nstring left_file = \"../left.png\";\nstring disparity_file = \"../disparity.png\";\nboost::format fmt_others(\"../%06d.png\"); // other files\n\n// useful typedefs\ntypedef Eigen::Matrix Matrix6d;\ntypedef Eigen::Matrix Matrix26d;\ntypedef Eigen::Matrix Vector6d;\n\n// TODO implement this function\n/**\n * pose estimation using direct method\n * @param img1\n * @param img2\n * @param px_ref\n * @param depth_ref\n * @param T21\n */\nvoid DirectPoseEstimationMultiLayer(\n const cv::Mat &img1,\n const cv::Mat &img2,\n const VecVector2d &px_ref,\n const vector depth_ref,\n Sophus::SE3 &T21\n);\n\n// TODO implement this function\n/**\n * pose estimation using direct method\n * @param img1\n * @param img2\n * @param px_ref\n * @param depth_ref\n * @param T21\n */\nvoid DirectPoseEstimationSingleLayer(\n const cv::Mat &img1,\n const cv::Mat &img2,\n const VecVector2d &px_ref,\n const vector depth_ref,\n Sophus::SE3 &T21\n);\n\n// bilinear interpolation\ninline float GetPixelValue(const cv::Mat &img, float x, float y) {\n uchar *data = &img.data[int(y) * img.step + int(x)];\n float xx = x - floor(x);\n float yy = y - floor(y);\n return float(\n (1 - xx) * (1 - yy) * data[0] +\n xx * (1 - yy) * data[1] +\n (1 - xx) * yy * data[img.step] +\n xx * yy * data[img.step + 1]\n );\n}\n\ninline bool OutOfImg(float u, float v, int col, int row){\n\tif(u >= 0 && u < col && v >= 0 && v < row)\n\t\treturn false;\n\telse{\n\t\treturn true;\n\t}\n}\n\nint main(int argc, char **argv) {\n\n cv::Mat left_img = cv::imread(left_file, 0);\n cv::Mat disparity_img = cv::imread(disparity_file, 0);\n\n // let's randomly pick pixels in the first image and generate some 3d points in the first image's frame\n cv::RNG rng;\n int nPoints = 1000;\n int boarder = 40;\n VecVector2d pixels_ref;\n vector depth_ref;\n\n // generate pixels in ref and load depth data\n for (int i = 0; i < nPoints; i++) {\n int x = rng.uniform(boarder, left_img.cols - boarder); // don't pick pixels close to boarder\n int y = rng.uniform(boarder, left_img.rows - boarder); // don't pick pixels close to boarder\n int disparity = disparity_img.at(y, x);\n double depth = fx * baseline / disparity; // you know this is disparity to depth\n depth_ref.push_back(depth);\n pixels_ref.push_back(Eigen::Vector2d(x, y));\n }\n\n // estimates 01~05.png's pose using this information\n Sophus::SE3 T_cur_ref;\n\n for (int i = 1; i < 6; i++) { // 1~10\n cv::Mat img = cv::imread((fmt_others % i).str(), 0);\n // DirectPoseEstimationSingleLayer(left_img, img, pixels_ref, depth_ref, T_cur_ref); // first you need to test single layer\n DirectPoseEstimationMultiLayer(left_img, img, pixels_ref, depth_ref, T_cur_ref);\n }\n}\n\nvoid DirectPoseEstimationSingleLayer(\n const cv::Mat &img1,\n const cv::Mat &img2,\n const VecVector2d &px_ref,\n const vector depth_ref,\n Sophus::SE3 &T21\n) {\n\n // parameters\n int half_patch_size = 4;\n int iterations = 100;\n\n double cost = 0, lastCost = 0;\n int nGood = 0; // good projections\n VecVector2d goodProjection;\n\n for (int iter = 0; iter < iterations; iter++) {\n nGood = 0;\n goodProjection.clear();\n\n // Define Hessian and bias\n Matrix6d H = Matrix6d::Zero(); // 6x6 Hessian\n Vector6d b = Vector6d::Zero(); // 6x1 bias\n\n for (size_t i = 0; i < px_ref.size(); i++) {\n\n // compute the projection in the second image\n // TODO START YOUR CODE HERE\n float u = px_ref[i](0), v = px_ref[i](1);\n\t\t\tdouble zCam1 = depth_ref[i];\n\t\t\tdouble xCam1 = double(zCam1 / fx * (u - cx));\n\t\t\tdouble yCam1 = double(zCam1 / fy * (v - cy));\n\t\t\tVector3d pCam1(xCam1, yCam1, zCam1);\n\t\t\tVector3d pCam2 = T21 * pCam1;\n\t\t\tdouble xCam2 = pCam2[0], yCam2 = pCam2[1], zCam2 = pCam2[2];\n\t\t\tfloat u2 = float(fx * xCam2 / zCam2 + cx);\n\t\t\tfloat v2 = float(fy * yCam2 / zCam2 + cy);\n\t\t\t\n\t\t\tif(OutOfImg(u-half_patch_size, v-half_patch_size, img1.cols, img1.rows)\n\t\t\t || OutOfImg(u+half_patch_size-1, v+half_patch_size-1, img1.cols, img1.rows) \n\t\t\t || OutOfImg(u2-half_patch_size, v2-half_patch_size, img2.cols, img2.rows)\n\t\t\t || OutOfImg(u2+half_patch_size-1, v2+half_patch_size-1, img2.cols, img2.rows)\n\t\t\t ){\n\t\t\t//\tcout << \"[DM] pixel out of img \" << endl;\n\t\t\t//\tcout << u << \" \" << v << \" \" << img1.cols << \" \" << img1.rows << endl;\n\t\t\t//\tcout << u2 << \" \" << v2 << \" \" << img2.cols << \" \" << img2.rows << endl;\n\t\t\t\tcontinue;\n\t\t\t}\n\n//\t\t\tcout << \"uv in cam1:\" << u << \" \" << v << endl;\n//\t\t\tcout << \"uv in cam2:\" << u2 << \" \" << v2 << endl;\n//\t\t\tcout << \"p in cam2: \" << pCam2 << endl; \n//\t\t\tcout << \"p in cam1: \" << pCam1 << endl; \n nGood++;\n goodProjection.push_back(Eigen::Vector2d(u2, v2));\n\n\t\t\tdouble xCam2_2 = xCam2 * xCam2, yCam2_2 = yCam2 * yCam2, zCam2_2 = zCam2 * zCam2;\n\t\t\tMatrix26d J_pixel_xi; // pixel to \\xi in Lie algebra\n\t\t\tJ_pixel_xi(0,0) = fx / zCam2;\n\t\t\tJ_pixel_xi(0,1) = 0;\n\t\t J_pixel_xi(0,2) = - fx * xCam2 / zCam2_2;\n\t\t J_pixel_xi(0,3) = - fx * xCam2 * yCam2 / zCam2_2;\n\t\t J_pixel_xi(0,4) = fx + fx * xCam2_2 / zCam2_2;\n\t\t J_pixel_xi(0,5) = - fx * yCam2 / zCam2;\n\t\t J_pixel_xi(1,0) = 0;\n\t\t J_pixel_xi(1,1) = fy / zCam2;\n\t\t J_pixel_xi(1,2) = -fy * yCam2 / zCam2_2;\n\t\t J_pixel_xi(1,3) = -fy - fy * yCam2_2 / zCam2_2;\n\t\t J_pixel_xi(1,4) = fy * xCam2 * yCam2 / zCam2_2;\n\t\t J_pixel_xi(1,5) = fy * xCam2 / zCam2;\n \n\t\t\t// and compute error and jacobian\n for (int x = -half_patch_size; x < half_patch_size; x++)\n for (int y = -half_patch_size; y < half_patch_size; y++) {\n\n double error = 0;\n Eigen::Vector2d J_img_pixel; // image gradients\n\n float u1_patch = u + x, v1_patch = v + y;\n\t\t\t\t\tfloat u2_patch = u2 + x, v2_patch = v2 + y;\n\t\t\t\t\terror = GetPixelValue(img1, u1_patch, v1_patch) - GetPixelValue(img2, u2_patch, v2_patch);\n\t\t \t\tJ_img_pixel[0] = (GetPixelValue(img2, u2_patch + 1, v2_patch) - GetPixelValue(img2, u2_patch - 1, v2_patch)) / 2;\n\t\t \t\t\tJ_img_pixel[1] = (GetPixelValue(img2, u2_patch, v2_patch + 1) - GetPixelValue(img2, u2_patch, v2_patch - 1)) / 2 ;\t\n\t\t\t\t\t// total jacobian\n Vector6d J = -J_pixel_xi.transpose() * J_img_pixel;\n\n H += J * J.transpose();\n b += -error * J;\n cost += error * error;\n }\n // END YOUR CODE HERE\n }\n\n // solve update and put it into estimation\n // TODO START YOUR CODE HERE\n Vector6d update;\n\t\tupdate = H.ldlt().solve(b);\n T21 = Sophus::SE3::exp(update) * T21;\n // END YOUR CODE HERE\n\n cost /= nGood;\n\n if (std::isnan(update[0])) {\n // sometimes occurred when we have a black or white patch and H is irreversible\n cout << \"update is nan\" << endl;\n break;\n }\n if (iter > 0 && cost > lastCost) {\n// cout << \"cost increased: \" << cost << \", \" << lastCost << endl;\n break;\n }\n lastCost = cost;\n// cout << \"cost = \" << cost << \", good = \" << nGood << endl;\n }\n// cout << \"good projection: \" << nGood << endl;\n// cout << \"T21 = \\n\" << T21.matrix() << endl;\n\n // in order to help you debug, we plot the projected pixels here\n// cv::Mat img1_show, img2_show;\n// cv::cvtColor(img1, img1_show, CV_GRAY2BGR);\n// cv::cvtColor(img2, img2_show, CV_GRAY2BGR);\n// for (auto &px: px_ref) {\n// cv::rectangle(img1_show, cv::Point2f(px[0] - 2, px[1] - 2), cv::Point2f(px[0] + 2, px[1] + 2),\n// cv::Scalar(0, 250, 0));\n// }\n// for (auto &px: goodProjection) {\n// cv::rectangle(img2_show, cv::Point2f(px[0] - 2, px[1] - 2), cv::Point2f(px[0] + 2, px[1] + 2),\n// cv::Scalar(0, 250, 0));\n// }\n// cv::imshow(\"reference\", img1_show);\n// cv::imshow(\"current\", img2_show);\n// cv::waitKey();\n}\n\nvoid DirectPoseEstimationMultiLayer(\n const cv::Mat &img1,\n const cv::Mat &img2,\n const VecVector2d &px_ref,\n const vector depth_ref,\n Sophus::SE3 &T21\n) {\n\n // parameters\n int pyramids = 4;\n double pyramid_scale = 0.5;\n double scales[] = {1.0, 0.5, 0.25, 0.125};\n\n // create pyramids\n vector pyr1, pyr2; // image pyramids\n // TODO START YOUR CODE HERE\n\tfor(int i = 0; i < pyramids; i++){\n\t\tMat img1_resize, img2_resize;\n\t\tcv::resize(img1, img1_resize, Size(img1.cols * scales[i], img1.rows * scales[i]));\n\t\tcv::resize(img2, img2_resize, Size(img2.cols * scales[i], img2.rows * scales[i]));\n\t\tpyr1.push_back(img1_resize);\n\t\tpyr2.push_back(img2_resize);\n\t}\n // END YOUR CODE HERE\n\n double fxG = fx, fyG = fy, cxG = cx, cyG = cy; // backup the old values\n for (int level = pyramids - 1; level >= 0; level--) {\n VecVector2d px_ref_pyr; // set the keypoints in this pyramid level\n for (auto &px: px_ref) {\n px_ref_pyr.push_back(scales[level] * px);\n }\n\n // TODO START YOUR CODE HERE\n // scale fx, fy, cx, cy in different pyramid levels\n\t\tfx = fxG * scales[level];\n\t\tfy = fyG * scales[level];\n\t\tcx = cxG * scales[level];\n\t\tcy = cyG * scales[level];\n\n // END YOUR CODE HERE\n DirectPoseEstimationSingleLayer(pyr1[level], pyr2[level], px_ref_pyr, depth_ref, T21);//T21 have add before's cal result.\n }\n\tcout << \"Multi T21 = \\n\" << T21.matrix() << endl;\n}\n", "meta": {"hexsha": "2629064ad49f46b9096979ca1e90109a45562467", "size": 10084, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "slam/PA6_code/code/direct_method.cpp", "max_stars_repo_name": "wallEVA96/algorithm", "max_stars_repo_head_hexsha": "c64e50eff9ad928015ce2780086dd9682c8e2220", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 19.0, "max_stars_repo_stars_event_min_datetime": "2018-12-27T05:44:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T03:36:15.000Z", "max_issues_repo_path": "slam/PA6_code/code/direct_method.cpp", "max_issues_repo_name": "wallEVA96/algorithm", "max_issues_repo_head_hexsha": "c64e50eff9ad928015ce2780086dd9682c8e2220", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "slam/PA6_code/code/direct_method.cpp", "max_forks_repo_name": "wallEVA96/algorithm", "max_forks_repo_head_hexsha": "c64e50eff9ad928015ce2780086dd9682c8e2220", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2020-04-23T02:01:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-28T02:55:16.000Z", "avg_line_length": 34.1830508475, "max_line_length": 133, "alphanum_fraction": 0.5800277668, "num_tokens": 3225, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.822189134878876, "lm_q2_score": 0.6076631698328917, "lm_q1q2_score": 0.4996140559026607}} {"text": "#include \n#include \n#include \n#include \n\nnamespace lm\n{\nbox2f get_box(Eigen::Vector2f extents) { return box2f{-extents, extents}; }\n\nfloat distance(Eigen::Vector2f point, Eigen::Vector2f box_extents)\n{\n box2f box = get_box(box_extents);\n\n if (boost::geometry::within(point, box))\n {\n Eigen::Vector2f a{-box_extents[0], -box_extents[1]},\n b{-box_extents[0], box_extents[1]}, c{box_extents[0], box_extents[1]},\n d{box_extents[0], -box_extents[1]};\n\n std::initializer_list segments{\n {a, b}, {b, c}, {c, d}, {d, a}};\n\n float distance{std::numeric_limits::max()};\n\n for (auto segment : segments)\n {\n distance = std::min(\n (float)boost::geometry::distance(segment, point), distance);\n }\n return -distance;\n }\n\n return boost::geometry::distance(point, box);\n}\n\nstd::pair\n closest_edge(Eigen::Vector2f point, Eigen::Vector2f box_extents)\n{\n Eigen::Vector2f a{-box_extents[0], -box_extents[1]},\n b{-box_extents[0], box_extents[1]}, c{box_extents[0], box_extents[1]},\n d{box_extents[0], -box_extents[1]};\n\n std::initializer_list segments{{a, b}, {b, c}, {c, d}, {d, a}};\n\n float min_distance{std::numeric_limits::max()};\n segment2f closest;\n\n for (auto segment : segments)\n {\n double segment_distance = boost::geometry::distance(segment, point);\n if (segment_distance < min_distance)\n {\n min_distance = segment_distance;\n closest = segment;\n }\n }\n\n return {closest, min_distance};\n}\n} // namespace lm\n", "meta": {"hexsha": "7b6a0aa7fb9ff341b2072940b4a0dee9d13f2d53", "size": 1709, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "lmlib/src/geometry/intersection.cpp", "max_stars_repo_name": "Lawrencemm/LM-Engine", "max_stars_repo_head_hexsha": "9c5e59e64e2a5a24c347538fa49046ab5a88d1f5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 40.0, "max_stars_repo_stars_event_min_datetime": "2020-03-13T06:12:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-16T21:05:34.000Z", "max_issues_repo_path": "lmlib/src/geometry/intersection.cpp", "max_issues_repo_name": "Lawrencemm/LM-Engine", "max_issues_repo_head_hexsha": "9c5e59e64e2a5a24c347538fa49046ab5a88d1f5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 31.0, "max_issues_repo_issues_event_min_datetime": "2020-02-09T06:25:12.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-31T04:37:08.000Z", "max_forks_repo_path": "lmlib/src/geometry/intersection.cpp", "max_forks_repo_name": "Lawrencemm/LM-Engine", "max_forks_repo_head_hexsha": "9c5e59e64e2a5a24c347538fa49046ab5a88d1f5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-03-13T06:12:12.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-21T15:41:17.000Z", "avg_line_length": 28.0163934426, "max_line_length": 80, "alphanum_fraction": 0.6184903452, "num_tokens": 482, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891305219504, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.49961405325511743}} {"text": "/*-------------Lanczos.cpp----------------------------------------------------//\n*\n* Purpose: To diagonalize a random matrix using the Lanczos algorithm\n*\n* Notes: Compile with (for Arch systems):\n* g++ -I /usr/include/eigen3/ Lanczos.cpp\n* 0's along the prime diagonal. I don't know what this means.\n*\n*-----------------------------------------------------------------------------*/\n \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace Eigen;\n\n// Function for the lanczos algorithm, returns Tri-diagonal matrix\nMatrixXd lanczos(MatrixXd &d_matrix, int row_num);\n\n// Function for QR decomposition\nMatrixXd qrdecomp(MatrixXd &Tridiag);\n\n// Function to perform the Power Method\nvoid p_method(MatrixXd &Tridiag, MatrixXd &Q);\n\n// Function to return sign of value (signum function)\nint sign(double value);\n\n// Function to check eigenvectors and values\nvoid eigentest(MatrixXd &d_matrix, MatrixXd &Q);\n\n/*----------------------------------------------------------------------------//\n* MAIN\n*-----------------------------------------------------------------------------*/\n\nint main(){\n\n int size = 200;\n MatrixXd d_matrix(size,size);\n\n // set up random device\n static std::random_device rd;\n int seed = rd();\n static std::mt19937 gen(seed);\n std::uniform_real_distribution dist(0,1);\n\n for (size_t i = 0; i < d_matrix.rows(); ++i){\n for (size_t j = 0; j <= i; ++j){\n d_matrix(i,j) = dist(gen);\n d_matrix(j,i) = d_matrix(i,j);\n }\n }\n\n MatrixXd Tridiag = lanczos(d_matrix, 20);\n\n //std::cout << '\\n' << \"Tridiagonal matrix is: \\n\" << Tridiag << '\\n';\n\n /*\n // Testing for eigenvalue determination\n MatrixXd Tridiag(3,3);\n Tridiag << 1, 2, 0,\n 2, 1, 0,\n 0, 0, -3;\n\n MatrixXd Tridiag(5,5);\n Tridiag << 5, 0, 0, 0, 0,\n 0, 4, 0, 0, 0,\n 0, 0, 3, 0, 0,\n 0, 0, 0, 2, 0,\n 0, 0, 0, 0, 7;\n Tridiag = lanczos(Tridiag, 5);\n */\n\n //std::cout << \"Tridiag is: \" << '\\n' << Tridiag << '\\n';\n\n MatrixXd Q = qrdecomp(Tridiag);\n\n MatrixXd Qtemp = Q;\n\n //std::cout << \"Q is: \" << '\\n';\n //std::cout << Q << '\\n';\n\n std::cout << \"Finding eigenvalues: \" << '\\n';\n p_method(Tridiag, Q);\n\n //std::cout << \"Q is: \" << '\\n' << Q << '\\n';\n\n Qtemp = Qtemp - Q;\n //std::cout << \"After the Power Method: \" << Qtemp.squaredNorm() << '\\n';\n eigentest(Tridiag, Q);\n\n}\n\n/*----------------------------------------------------------------------------//\n* SUBROUTINE\n*-----------------------------------------------------------------------------*/\n\n// Function for the lanczos algorithm, returns Tri-diagonal matrix\nMatrixXd lanczos(MatrixXd &d_matrix, int row_num){\n\n // Creating random device\n static std::random_device rd;\n int seed = rd();\n static std::mt19937 gen(seed);\n std::uniform_real_distribution dist(0,1); \n\n // Defining values\n double threshold = 0.01;\n int j = 0;\n int size = d_matrix.rows();\n\n // Setting beta arbitrarily large for now \n double beta = 10;\n\n // generating the first rayleigh vector\n // alpha is actually just a double... sorry about that.\n MatrixXd rayleigh(d_matrix.rows(),1), q(d_matrix.rows(),1),\n alpha(1, 1);\n MatrixXd identity = MatrixXd::Identity(d_matrix.rows(), d_matrix.cols());\n\n // krylov is the krylovian subspace... Note, there might be a dynamic way to\n // do this. Something like:\n //std::vector krylov;\n MatrixXd krylov(d_matrix.rows(), row_num);\n\n for (size_t i = 0; i < size; ++i){\n rayleigh(i) = dist(gen);\n }\n\n //std::cout << rayleigh << '\\n';\n\n //while (beta > threshold){\n for (size_t i = 0; i < row_num; ++i){\n beta = rayleigh.norm();\n //std::cout << \"beta is: \\n\" << beta << '\\n';\n\n q = rayleigh / beta;\n //std::cout << \"q is: \\n\" << q << '\\n';\n\n alpha = q.transpose() * d_matrix * q;\n //std::cout << \"alpha is \\n\" << alpha << '\\n';\n\n if (j == 0){\n rayleigh = (d_matrix - alpha(0,0) * identity) * q;\n }\n else{\n rayleigh = (d_matrix - alpha(0,0) * identity) * q \n - beta * krylov.col(j - 1);\n\n }\n //std::cout << \"rayleigh is: \\n\" << rayleigh <<'\\n';\n //std::cout << \"i is: \" << i << '\\n';\n\n //krylov.push_back(q);\n krylov.col(j) = q;\n j = j+1;\n // std::cout << j << '\\n';\n }\n\n /*\n MatrixXd krylov_id = krylov.transpose() * krylov;\n std::cout << \"The identity matrix from the krylov subspace is: \\n\" \n << krylov_id << '\\n';\n */\n\n MatrixXd T(row_num,row_num);\n T = krylov.transpose() * d_matrix * krylov;\n\n return T;\n}\n\n// Function for QR decomposition\n// Because we only need Q for the power method, I will retun only Q\nMatrixXd qrdecomp(MatrixXd &Tridiag){\n // Q is and orthonormal vector => Q'Q = 1\n MatrixXd Id = MatrixXd::Identity(Tridiag.rows(), Tridiag.cols());\n MatrixXd Q = Id;\n MatrixXd P(Tridiag.rows(), Tridiag.cols());\n\n // R is the upper triangular matrix\n MatrixXd R = Tridiag;\n\n int row_num = Tridiag.rows();\n int countx = 0, county = 0;\n\n // Scale R \n double sum = 0.0, sigma, tau, fak, max_val = 0;\n\n bool sing;\n\n // Defining vectors for algorithm\n MatrixXd diag(row_num,1);\n\n //std::cout << R << '\\n';\n\n for (int i = 0; i < row_num-1; ++i){\n diag = MatrixXd::Zero(row_num, 1);\n\n sum = 0;\n for (size_t j = i; j < row_num; ++j){\n sum += R(j,i) * R(j,i);\n //std::cout << R(j,i) << '\\n';\n }\n sum = sqrt(sum);\n\n if (R(i,i) > 0){\n sigma = -sum;\n }\n else{\n sigma = sum;\n }\n\n //std::cout << \"sigma is: \" << sigma << '\\n';\n\n sum = 0;\n //diag = R.block(i,i, row_num - i, 1);\n //std::cout << \"diag is: \" << '\\n';\n for (int j = i; j < row_num; ++j){\n //std::cout << i << '\\t' << j << '\\n';\n if (j == i){\n diag(j) = R(j,i) + sigma;\n }\n else{\n diag(j) = R(j, i);\n }\n //std::cout << diag(j) << '\\n';\n sum = sum + diag(j) * diag(j);\n }\n sum = sqrt(sum);\n\n //std::cout << \"sum is: \" << sum << '\\n';\n\n if (sum > 0.000000000000001){\n\n for (int j = i; j < row_num; ++j){\n diag(j) = diag(j) / sum;\n }\n \n //std::cout << \"normalized diag is: \" << '\\n' << diag << '\\n';\n \n P = Id - (diag * diag.transpose()) * 2.0;\n \n R = P * R;\n Q = Q * P;\n }\n\n //std::cout << \"R is: \" << R << '\\n';\n\n }\n //std::cout << \"R is: \" << R << '\\n';\n //std::cout << \"Q is: \" << Q << '\\n';\n\n //std::cout << \"QR is: \" << '\\n' << Q*R << '\\n';\n\n //std::cout << \"Q^T * Q is: \" << '\\n' << Q.transpose() * Q << '\\n' << '\\n';\n //std::cout << \"QR - A is: \" << '\\n' << Q*R - Tridiag << '\\n';\n //std::cout << \"Q^T * A - R: \" << '\\n'\n // << Q.transpose() * Tridiag - R << '\\n' << '\\n';\n\n return Q;\n}\n\n// Function to perform the Power Method\nvoid p_method(MatrixXd &Tridiag, MatrixXd &Q){\n\n //std::cout << \"Q is: \" << '\\n' << Q << '\\n';\n //std::cout << \"Tridiag is : \" << '\\n' << Tridiag << '\\n';\n\n // Find all eigenvectors\n MatrixXd eigenvectors(Tridiag.rows(), Tridiag.cols());\n MatrixXd Z(Tridiag.rows(), Tridiag.cols());\n MatrixXd Qtemp = Q;\n\n // Iteratively defines eigenvectors\n for (int i = 0; i < Tridiag.rows(); ++i){\n Z = Tridiag * Q;\n Q = qrdecomp(Z);\n\n }\n\n Qtemp = Qtemp - Q;\n //std::cout << \"This should not be 0: \" << Qtemp.squaredNorm() << '\\n';\n\n}\n\n// Function to return sign of value (signum function)\nint sign(double value){\n if (value < 0.0){\n return -1;\n }\n else if (value > 0){\n return 1;\n }\n else {\n return 0;\n }\n}\n\n// Function to check eigenvectors and values\nvoid eigentest(MatrixXd &Tridiag, MatrixXd &Q){\n\n // Calculating the Rayleigh quotient (v^t * A * v) / (v^t * v)\n // Note, that this should be a representation of eigenvalues\n\n std::vector eigenvalues(Tridiag.rows());\n MatrixXd checkvector(Tridiag.rows(),1);\n double QQ, QAQ;\n\n for (size_t i = 0; i < Tridiag.rows(); ++i){\n QQ = Q.col(i).transpose() * Q.col(i); \n QAQ = Q.col(i).transpose() * Tridiag * Q.col(i);\n eigenvalues[i] = QAQ / QQ;\n std::cout << \"eigenvalue is: \" << eigenvalues[i] << '\\n';\n\n checkvector = ((Tridiag * Q.col(i)) / eigenvalues[i]) - Q.col(i);\n //std::cout << checkvector << '\\n' << '\\n';\n std::cout << \"This should be 0: \" << '\\t' \n << checkvector.squaredNorm() << '\\n';\n \n }\n\n}\n\n", "meta": {"hexsha": "f7ea3788ba2bf5fb8d1158e4d3f8dcddf6f7d35e", "size": 8946, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "DMRG/Lanczos.cpp", "max_stars_repo_name": "mika314/simuleios", "max_stars_repo_head_hexsha": "0b05660c7df0cd6e31eb5e70864cbedaec29b55a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 197.0, "max_stars_repo_stars_event_min_datetime": "2015-07-26T02:04:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-21T11:53:33.000Z", "max_issues_repo_path": "DMRG/Lanczos.cpp", "max_issues_repo_name": "shiffman/simuleios", "max_issues_repo_head_hexsha": "57239350d2cbed10893483bda65fa323e5e3a06d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 18.0, "max_issues_repo_issues_event_min_datetime": "2015-08-04T22:55:46.000Z", "max_issues_repo_issues_event_max_datetime": "2020-11-06T02:33:48.000Z", "max_forks_repo_path": "DMRG/Lanczos.cpp", "max_forks_repo_name": "shiffman/simuleios", "max_forks_repo_head_hexsha": "57239350d2cbed10893483bda65fa323e5e3a06d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 55.0, "max_forks_repo_forks_event_min_datetime": "2015-08-02T21:43:18.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-13T18:25:08.000Z", "avg_line_length": 27.3577981651, "max_line_length": 80, "alphanum_fraction": 0.4765258216, "num_tokens": 2644, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.822189121808099, "lm_q2_score": 0.6076631698328917, "lm_q1q2_score": 0.49961404796003095}} {"text": "/**\n * Copyright (C) Omar Thor - All Rights Reserved\n * Unauthorized copying of this file, via any medium is strictly prohibited\n * Proprietary and confidential\n *\n * Written by Omar Thor , 2017\n */\n\n#ifndef SP_ALGO_NN_LAYER_CONV_HPP\n#define SP_ALGO_NN_LAYER_CONV_HPP\n\n#include \n\n#include \"layer.hpp\"\n#include \"connectivity.hpp\"\n#include \"detail/layers.hpp\"\n#include \"sp/util/types.hpp\"\n#include \"params.hpp\"\n\n\nSP_ALGO_NN_NAMESPACE_BEGIN\n\n/**\n * \\brief Convolutional Layer implementation\n *\n * Convolves input by a set of feature kernels and returns the convolution\n * results\n *\n * Note: This convolution implementation does not rotate the kernel\n * and is therefore not convolution but cross correlation, mathematically\n * speaking.\n *\n * Summary of parameters (Soft and Hard, i.e. parameterized and derived)\n * - N - Number of images in a mini-batch\n * - C - The number of input feature maps\n * - H - Height of input image\n * - W - Width of input image\n * - K - Number of output feature maps (number of kernels)\n * - R - Height of filter kernel\n * - S - Width of filter kernel\n * - U - Vertical Stride\n * - V - Horizontal Stride\n * - pad_h - Height of zero-padding\n * - pad_w - Width of zero-padding\n *\n * Output O of is a four dimensional tensor in R^NKPQ,\n * where ```P = f(H, R, u, pad_h) and Q = f(W, S, v, pad_w)```\n * where\n * * ```f(H, R, u, pad_h) = ceil((H - R + 1 + 2 * pad_h) / 2)```\n * * ```f(W, S, v, pad_w) = ceil((W - S + 1 + 2 * pad_w) / 2)```\n *\n * Convolution Modes (common LA terms, matlab, octave)\n * - valid - ```pad_w = pad_h = 0```\n * - same - ```pad_h = R/2 and pad_w = S / 2```\n * - full - ```pad_h = R - 1, pad_w = S - 1```\n *\n * \\tparam InputDim, includes:\n * - Width\n * - Height\n * - Depth (or channels)\n * \\tparam KernelDim, includes:... tbd\n * \\tparam Biased (optional) default true. Whether or not the layer contains bias.\n * \\tparam Sparsity The sparsity object. See #group_sparsity and #no_sparsity\n */\ntemplate<\n typename InputVolume,\n typename KernelParams = kernel_params_default,\n bool Biased = true,\n typename Connectivity = full_connectivity,\n size_t Dilation = 0\n>\nstruct conv_layer : layer<\n InputVolume,\n detail::convolution_kernel_out_dims_t,\n conv_layer\n> {\n\n /**\n * Base type\n */\n using base = layer<\n InputVolume,\n detail::convolution_kernel_out_dims_t,\n conv_layer\n >;\n\n /**\n * Validates KernelParams type\n */\n static_assert(util::is_instantiation_of_v, \"KernelParams template parameter must be an instance of kernel_params\");\n\n /**\n * Kernel parameters\n */\n using kernel_params = KernelParams;\n\n /**\n * Connectivity type (full, ngroups, etc)\n */\n using connectivity_type = Connectivity;\n\n /**\n * \\brief Dilation parameter\n * \\todo TBD: https://arxiv.org/abs/1511.07122\n */\n static_assert(Dilation == 0, \"Dilation is not implemented\");\n\n /**\n * Whether or not this layer has biased\n */\n constexpr static bool biased = Biased;\n\n /**\n * \\brief Input Dimensions\n */\n using input_dims = typename base::input_dims;\n\n /**\n * \\brief Output Dimensions\n */\n using output_dims = typename base::output_dims;\n\n /**\n * \\brief Weight dimensions\n */\n using weights_dims = weight_dims<\n output_dims::d,\n input_dims::d,\n kernel_params::h,\n kernel_params::w\n >;\n\n void forward_prop_impl(tensor_4& input, tensor_4& output) {\n\n /**\n * Number of samples in the input\n */\n const size_t samples = input.dimension(0);\n\n /**\n * Perform forward propagation for every sample\n */\n #pragma omp parallel for simd\n for (size_t si = 0; si < samples; ++si) {\n /**\n * Loop over the pairs of (D_out, D_in), i.e. input_dims::d*output_dims::d\n */\n for (size_t od = 0; od < output_dims::d; ++od) {\n for (size_t id = 0; id < input_dims::d; ++id) {\n if(connections(od, id)) {\n /*\n * If the output channel is connected to the input channel,\n * then perform convolution. This is done to support limited\n * connectivity when required\n *\n * Then, perform the convolution op\n *\n * \\todo add dilation\n * \\todo Optimize for smaller kernels (common, 2x2, 3x3, etc)\n */\n for (size_t oy = 0, iny = 0; oy < output_dims::h; ++oy, iny += kernel_params::s_h) {\n for (size_t ox = 0, inx = 0; ox < output_dims::w; ++ox, inx += kernel_params::s_w) {\n float_t sum = 0;\n for (size_t ky = 0; ky < kernel_params::h; ++ky) {\n for (size_t kx = 0; kx < kernel_params::w; ++kx) {\n auto& in_val = input(si, id, iny+ky, inx+kx);\n auto& w_val = w(od, id, ky, kx);\n sum += in_val * w_val;\n }\n }\n output(si, od, oy, ox) += sum;\n }\n }\n }\n }\n if constexpr(biased) {\n /**\n * Add bias to every output vector the depth slice at output(od)\n */\n output.chip(si, 0).chip(od, 0) = output.chip(si, 0).chip(od, 0) + b(od);\n }\n }\n }\n }\n\n /**\n * \\brief Back propagation implementation\n *\n * \\todo Optimize\n */\n void backward_prop_impl( tensor_4& prev_out,\n tensor_4& prev_delta,\n tensor_4& curr_out,\n tensor_4& curr_delta) {\n\n\n /**\n * Number of samples in the previous output\n */\n const size_t samples = prev_out.dimension(0);\n\n /**\n * Perform back propagation\n *\n * For every sample in the input\n */\n #pragma omp parallel for simd\n for(size_t si = 0; si < samples; ++si) {\n /**\n * For every (input depth, output depth) pair that is connected\n */\n for (size_t id = 0; id < input_dims::d; ++id) {\n for (size_t od = 0; od < output_dims::d; ++od) {\n if(connections(od, id)) {\n /* Propagate the current delta to the previous delta through the kernel */\n for (size_t oy = 0, iny = 0; oy < output_dims::h; ++oy, iny += kernel_params::s_h) {\n for (size_t ox = 0, inx = 0; ox < output_dims::w; ++ox, inx += kernel_params::s_w) {\n float_t& grad = curr_delta(si, od, oy, ox);\n for (size_t wy = 0; wy < weights_dims::h; ++wy) {\n for (size_t wx = 0; wx < weights_dims::w; ++wx) {\n auto& w_val = w(od, id, wy, wx);\n prev_delta(si, id, iny + wy, inx + wx) += w_val * grad;\n }\n }\n }\n }\n }\n }\n }\n for (size_t id = 0; id < input_dims::d; ++id) {\n for (size_t od = 0; od < output_dims::d; ++od) {\n if(connections(od, id)) {\n for (size_t wy = 0; wy < weights_dims::h; ++wy) {\n for (size_t wx = 0; wx < weights_dims::w; ++wx) {\n float_t delta = 0;\n for (size_t oy = 0, iny = 0; oy < output_dims::h; ++oy, iny += kernel_params::s_h) {\n for (size_t ox = 0, inx = 0; ox < output_dims::w; ++ox, inx += kernel_params::s_w) {\n auto& po = prev_out(si, id, oy + wy, ox + wx);\n auto& cd = curr_delta(si, od, oy, ox);\n delta += po * cd;\n }\n }\n dw(si, od, id, wy, wx) += delta;\n }\n }\n }\n }\n }\n if (biased) {\n for (size_t od = 0; od < output_dims::d; ++od) {\n tensor_0 sum = curr_delta.chip(si, 0).chip(od, 0).sum();\n db(si, od) += sum(0);\n }\n }\n }\n }\n\n /**\n * \\brief Weights of the layer.\n */\n weights_type w;\n\n /**\n * Weights Delta\n */\n weights_delta_type dw;\n\n /**\n * \\brief Bias.\n */\n bias_type b;\n\n /**\n * Bias Delta.\n */\n bias_delta_type db;\n\n connectivity_type connections;\n\n};\n\n\nSP_ALGO_GEN_NAMESPACE_END\n\n#endif\t/* SP_ALGO_NN_LAYER_CONV_HPP */\n\n", "meta": {"hexsha": "59cf223ad9bd2ec3a4ce550068734759607b0686", "size": 9612, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/sp/algo/nn/layer/convolution.hpp", "max_stars_repo_name": "thorigin/sp", "max_stars_repo_head_hexsha": "a837b4fcb5b7184591585082012942bbdb8f11f9", "max_stars_repo_licenses": ["FSFAP"], "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/sp/algo/nn/layer/convolution.hpp", "max_issues_repo_name": "thorigin/sp", "max_issues_repo_head_hexsha": "a837b4fcb5b7184591585082012942bbdb8f11f9", "max_issues_repo_licenses": ["FSFAP"], "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/sp/algo/nn/layer/convolution.hpp", "max_forks_repo_name": "thorigin/sp", "max_forks_repo_head_hexsha": "a837b4fcb5b7184591585082012942bbdb8f11f9", "max_forks_repo_licenses": ["FSFAP"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.4912891986, "max_line_length": 148, "alphanum_fraction": 0.4783603829, "num_tokens": 2299, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199511728004, "lm_q2_score": 0.5964331462646255, "lm_q1q2_score": 0.4995843028520153}} {"text": "// (C) Copyright Nick Thompson 2019.\n// Use, modification and distribution are subject to the\n// Boost Software License, Version 1.0. (See accompanying file\n// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n\n#ifndef BOOST_MATH_DIFFERENTIATION_LANCZOS_SMOOTHING_HPP\n#define BOOST_MATH_DIFFERENTIATION_LANCZOS_SMOOTHING_HPP\n#include // for std::abs\n#include \n#include // to nan initialize\n#include \n#include \n#include \n#include \n#include \n\nnamespace boost::math::differentiation {\n\nnamespace detail {\ntemplate \nclass discrete_legendre {\n public:\n explicit discrete_legendre(std::size_t n, Real x) : m_n{n}, m_r{2}, m_x{x},\n m_qrm2{1}, m_qrm1{x},\n m_qrm2p{0}, m_qrm1p{1},\n m_qrm2pp{0}, m_qrm1pp{0}\n {\n using std::abs;\n BOOST_MATH_ASSERT_MSG(abs(m_x) <= 1, \"Three term recurrence is stable only for |x| <=1.\");\n // The integer n indexes a family of discrete Legendre polynomials indexed by k <= 2*n\n }\n\n Real norm_sq(int r) const\n {\n Real prod = Real(2) / Real(2 * r + 1);\n for (int k = -r; k <= r; ++k) {\n prod *= Real(2 * m_n + 1 + k) / Real(2 * m_n);\n }\n return prod;\n }\n\n Real next()\n {\n Real N = 2 * m_n + 1;\n Real num = (m_r - 1) * (N * N - (m_r - 1) * (m_r - 1)) * m_qrm2;\n Real tmp = (2 * m_r - 1) * m_x * m_qrm1 - num / Real(4 * m_n * m_n);\n m_qrm2 = m_qrm1;\n m_qrm1 = tmp / m_r;\n ++m_r;\n return m_qrm1;\n }\n\n Real next_prime()\n {\n Real N = 2 * m_n + 1;\n Real s = (m_r - 1) * (N * N - (m_r - 1) * (m_r - 1)) / Real(4 * m_n * m_n);\n Real tmp1 = ((2 * m_r - 1) * m_x * m_qrm1 - s * m_qrm2) / m_r;\n Real tmp2 = ((2 * m_r - 1) * (m_qrm1 + m_x * m_qrm1p) - s * m_qrm2p) / m_r;\n m_qrm2 = m_qrm1;\n m_qrm1 = tmp1;\n m_qrm2p = m_qrm1p;\n m_qrm1p = tmp2;\n ++m_r;\n return m_qrm1p;\n }\n\n Real next_dbl_prime()\n {\n Real N = 2*m_n + 1;\n Real trm1 = 2*m_r - 1;\n Real s = (m_r - 1) * (N * N - (m_r - 1) * (m_r - 1)) / Real(4 * m_n * m_n);\n Real rqrpp = 2*trm1*m_qrm1p + trm1*m_x*m_qrm1pp - s*m_qrm2pp;\n Real tmp1 = ((2 * m_r - 1) * m_x * m_qrm1 - s * m_qrm2) / m_r;\n Real tmp2 = ((2 * m_r - 1) * (m_qrm1 + m_x * m_qrm1p) - s * m_qrm2p) / m_r;\n m_qrm2 = m_qrm1;\n m_qrm1 = tmp1;\n m_qrm2p = m_qrm1p;\n m_qrm1p = tmp2;\n m_qrm2pp = m_qrm1pp;\n m_qrm1pp = rqrpp/m_r;\n ++m_r;\n return m_qrm1pp;\n }\n\n Real operator()(Real x, std::size_t k)\n {\n BOOST_MATH_ASSERT_MSG(k <= 2 * m_n, \"r <= 2n is required.\");\n if (k == 0)\n {\n return 1;\n }\n if (k == 1)\n {\n return x;\n }\n Real qrm2 = 1;\n Real qrm1 = x;\n Real N = 2 * m_n + 1;\n for (std::size_t r = 2; r <= k; ++r) {\n Real num = (r - 1) * (N * N - (r - 1) * (r - 1)) * qrm2;\n Real tmp = (2 * r - 1) * x * qrm1 - num / Real(4 * m_n * m_n);\n qrm2 = qrm1;\n qrm1 = tmp / r;\n }\n return qrm1;\n }\n\n Real prime(Real x, std::size_t k) {\n BOOST_MATH_ASSERT_MSG(k <= 2 * m_n, \"r <= 2n is required.\");\n if (k == 0) {\n return 0;\n }\n if (k == 1) {\n return 1;\n }\n Real qrm2 = 1;\n Real qrm1 = x;\n Real qrm2p = 0;\n Real qrm1p = 1;\n Real N = 2 * m_n + 1;\n for (std::size_t r = 2; r <= k; ++r) {\n Real s =\n (r - 1) * (N * N - (r - 1) * (r - 1)) / Real(4 * m_n * m_n);\n Real tmp1 = ((2 * r - 1) * x * qrm1 - s * qrm2) / r;\n Real tmp2 = ((2 * r - 1) * (qrm1 + x * qrm1p) - s * qrm2p) / r;\n qrm2 = qrm1;\n qrm1 = tmp1;\n qrm2p = qrm1p;\n qrm1p = tmp2;\n }\n return qrm1p;\n }\n\n private:\n std::size_t m_n;\n std::size_t m_r;\n Real m_x;\n Real m_qrm2;\n Real m_qrm1;\n Real m_qrm2p;\n Real m_qrm1p;\n Real m_qrm2pp;\n Real m_qrm1pp;\n};\n\ntemplate \nstd::vector interior_velocity_filter(std::size_t n, std::size_t p) {\n auto dlp = discrete_legendre(n, 0);\n std::vector coeffs(p+1);\n coeffs[1] = 1/dlp.norm_sq(1);\n for (std::size_t l = 3; l < p + 1; l += 2)\n {\n dlp.next_prime();\n coeffs[l] = dlp.next_prime()/ dlp.norm_sq(l);\n }\n\n // We could make the filter length n, as f[0] = 0,\n // but that'd make the indexing awkward when applying the filter.\n std::vector f(n + 1);\n // This value should never be read, but this is the correct value *if it is read*.\n // Hmm, should it be a nan then? I'm not gonna agonize.\n f[0] = 0;\n for (std::size_t j = 1; j < f.size(); ++j)\n {\n Real arg = Real(j) / Real(n);\n dlp = discrete_legendre(n, arg);\n f[j] = coeffs[1]*arg;\n for (std::size_t l = 3; l <= p; l += 2)\n {\n dlp.next();\n f[j] += coeffs[l]*dlp.next();\n }\n f[j] /= (n * n);\n }\n return f;\n}\n\ntemplate \nstd::vector boundary_velocity_filter(std::size_t n, std::size_t p, int64_t s)\n{\n std::vector coeffs(p+1, std::numeric_limits::quiet_NaN());\n Real sn = Real(s) / Real(n);\n auto dlp = discrete_legendre(n, sn);\n coeffs[0] = 0;\n coeffs[1] = 1/dlp.norm_sq(1);\n for (std::size_t l = 2; l < p + 1; ++l)\n {\n // Calculation of the norms is common to all filters,\n // so it seems like an obvious optimization target.\n // I tried this: The spent in computing the norms time is not negligible,\n // but still a small fraction of the total compute time.\n // Hence I'm not refactoring out these norm calculations.\n coeffs[l] = dlp.next_prime()/ dlp.norm_sq(l);\n }\n\n std::vector f(2*n + 1);\n for (std::size_t k = 0; k < f.size(); ++k)\n {\n Real j = Real(k) - Real(n);\n Real arg = j/Real(n);\n dlp = discrete_legendre(n, arg);\n f[k] = coeffs[1]*arg;\n for (std::size_t l = 2; l <= p; ++l)\n {\n f[k] += coeffs[l]*dlp.next();\n }\n f[k] /= (n * n);\n }\n return f;\n}\n\ntemplate \nstd::vector acceleration_filter(std::size_t n, std::size_t p, int64_t s)\n{\n BOOST_MATH_ASSERT_MSG(p <= 2*n, \"Approximation order must be <= 2*n\");\n BOOST_MATH_ASSERT_MSG(p > 2, \"Approximation order must be > 2\");\n\n std::vector coeffs(p+1, std::numeric_limits::quiet_NaN());\n Real sn = Real(s) / Real(n);\n auto dlp = discrete_legendre(n, sn);\n coeffs[0] = 0;\n coeffs[1] = 0;\n for (std::size_t l = 2; l < p + 1; ++l)\n {\n coeffs[l] = dlp.next_dbl_prime()/ dlp.norm_sq(l);\n }\n\n std::vector f(2*n + 1, 0);\n for (std::size_t k = 0; k < f.size(); ++k)\n {\n Real j = Real(k) - Real(n);\n Real arg = j/Real(n);\n dlp = discrete_legendre(n, arg);\n for (std::size_t l = 2; l <= p; ++l)\n {\n f[k] += coeffs[l]*dlp.next();\n }\n f[k] /= (n * n * n);\n }\n return f;\n}\n\n\n} // namespace detail\n\ntemplate \nclass discrete_lanczos_derivative {\npublic:\n discrete_lanczos_derivative(Real const & spacing,\n std::size_t n = 18,\n std::size_t approximation_order = 3)\n : m_dt{spacing}\n {\n static_assert(!std::is_integral_v,\n \"Spacing must be a floating point type.\");\n BOOST_MATH_ASSERT_MSG(spacing > 0,\n \"Spacing between samples must be > 0.\");\n\n if constexpr (order == 1)\n {\n BOOST_MATH_ASSERT_MSG(approximation_order <= 2 * n,\n \"The approximation order must be <= 2n\");\n BOOST_MATH_ASSERT_MSG(approximation_order >= 2,\n \"The approximation order must be >= 2\");\n\n if constexpr (std::is_same_v || std::is_same_v)\n {\n auto interior = detail::interior_velocity_filter(n, approximation_order);\n m_f.resize(interior.size());\n for (std::size_t j = 0; j < interior.size(); ++j)\n {\n m_f[j] = static_cast(interior[j])/m_dt;\n }\n }\n else\n {\n m_f = detail::interior_velocity_filter(n, approximation_order);\n for (auto & x : m_f)\n {\n x /= m_dt;\n }\n }\n\n m_boundary_filters.resize(n);\n // This for loop is a natural candidate for parallelization.\n // But does it matter? Probably not.\n for (std::size_t i = 0; i < n; ++i)\n {\n if constexpr (std::is_same_v || std::is_same_v)\n {\n int64_t s = static_cast(i) - static_cast(n);\n auto bf = detail::boundary_velocity_filter(n, approximation_order, s);\n m_boundary_filters[i].resize(bf.size());\n for (std::size_t j = 0; j < bf.size(); ++j)\n {\n m_boundary_filters[i][j] = static_cast(bf[j])/m_dt;\n }\n }\n else\n {\n int64_t s = static_cast(i) - static_cast(n);\n m_boundary_filters[i] = detail::boundary_velocity_filter(n, approximation_order, s);\n for (auto & bf : m_boundary_filters[i])\n {\n bf /= m_dt;\n }\n }\n }\n }\n else if constexpr (order == 2)\n {\n // High precision isn't warranted for small p; only for large p.\n // (The computation appears stable for large n.)\n // But given that the filters are reusable for many vectors,\n // it's better to do a high precision computation and then cast back,\n // since the resulting cost is a factor of 2, and the cost of the filters not working is hours of debugging.\n if constexpr (std::is_same_v || std::is_same_v)\n {\n auto f = detail::acceleration_filter(n, approximation_order, 0);\n m_f.resize(n+1);\n for (std::size_t i = 0; i < m_f.size(); ++i)\n {\n m_f[i] = static_cast(f[i+n])/(m_dt*m_dt);\n }\n m_boundary_filters.resize(n);\n for (std::size_t i = 0; i < n; ++i)\n {\n int64_t s = static_cast(i) - static_cast(n);\n auto bf = detail::acceleration_filter(n, approximation_order, s);\n m_boundary_filters[i].resize(bf.size());\n for (std::size_t j = 0; j < bf.size(); ++j)\n {\n m_boundary_filters[i][j] = static_cast(bf[j])/(m_dt*m_dt);\n }\n }\n }\n else\n {\n // Given that the purpose is denoising, for higher precision calculations,\n // the default precision should be fine.\n auto f = detail::acceleration_filter(n, approximation_order, 0);\n m_f.resize(n+1);\n for (std::size_t i = 0; i < m_f.size(); ++i)\n {\n m_f[i] = f[i+n]/(m_dt*m_dt);\n }\n m_boundary_filters.resize(n);\n for (std::size_t i = 0; i < n; ++i)\n {\n int64_t s = static_cast(i) - static_cast(n);\n m_boundary_filters[i] = detail::acceleration_filter(n, approximation_order, s);\n for (auto & bf : m_boundary_filters[i])\n {\n bf /= (m_dt*m_dt);\n }\n }\n }\n }\n else\n {\n BOOST_MATH_ASSERT_MSG(false, \"Derivatives of order 3 and higher are not implemented.\");\n }\n }\n\n Real get_spacing() const\n {\n return m_dt;\n }\n\n template\n Real operator()(RandomAccessContainer const & v, std::size_t i) const\n {\n static_assert(std::is_same_v,\n \"The type of the values in the vector provided does not match the type in the filters.\");\n\n BOOST_MATH_ASSERT_MSG(std::size(v) >= m_boundary_filters[0].size(),\n \"Vector must be at least as long as the filter length\");\n\n if constexpr (order==1)\n {\n if (i >= m_f.size() - 1 && i <= std::size(v) - m_f.size())\n {\n // The filter has length >= 1:\n Real dvdt = m_f[1] * (v[i + 1] - v[i - 1]);\n for (std::size_t j = 2; j < m_f.size(); ++j)\n {\n dvdt += m_f[j] * (v[i + j] - v[i - j]);\n }\n return dvdt;\n }\n\n // m_f.size() = N+1\n if (i < m_f.size() - 1)\n {\n auto &bf = m_boundary_filters[i];\n Real dvdt = bf[0]*v[0];\n for (std::size_t j = 1; j < bf.size(); ++j)\n {\n dvdt += bf[j] * v[j];\n }\n return dvdt;\n }\n\n if (i > std::size(v) - m_f.size() && i < std::size(v))\n {\n int k = std::size(v) - 1 - i;\n auto &bf = m_boundary_filters[k];\n Real dvdt = bf[0]*v[std::size(v)-1];\n for (std::size_t j = 1; j < bf.size(); ++j)\n {\n dvdt += bf[j] * v[std::size(v) - 1 - j];\n }\n return -dvdt;\n }\n }\n else if constexpr (order==2)\n {\n if (i >= m_f.size() - 1 && i <= std::size(v) - m_f.size())\n {\n Real d2vdt2 = m_f[0]*v[i];\n for (std::size_t j = 1; j < m_f.size(); ++j)\n {\n d2vdt2 += m_f[j] * (v[i + j] + v[i - j]);\n }\n return d2vdt2;\n }\n\n // m_f.size() = N+1\n if (i < m_f.size() - 1)\n {\n auto &bf = m_boundary_filters[i];\n Real d2vdt2 = bf[0]*v[0];\n for (std::size_t j = 1; j < bf.size(); ++j)\n {\n d2vdt2 += bf[j] * v[j];\n }\n return d2vdt2;\n }\n\n if (i > std::size(v) - m_f.size() && i < std::size(v))\n {\n int k = std::size(v) - 1 - i;\n auto &bf = m_boundary_filters[k];\n Real d2vdt2 = bf[0] * v[std::size(v) - 1];\n for (std::size_t j = 1; j < bf.size(); ++j)\n {\n d2vdt2 += bf[j] * v[std::size(v) - 1 - j];\n }\n return d2vdt2;\n }\n }\n\n // OOB access:\n std::string msg = \"Out of bounds access in Lanczos derivative.\";\n msg += \"Input vector has length \" + std::to_string(std::size(v)) + \", but user requested access at index \" + std::to_string(i) + \".\";\n throw std::out_of_range(msg);\n return std::numeric_limits::quiet_NaN();\n }\n\n template\n void operator()(RandomAccessContainer const & v, RandomAccessContainer & w) const\n {\n static_assert(std::is_same_v,\n \"The type of the values in the vector provided does not match the type in the filters.\");\n if (&w[0] == &v[0])\n {\n throw std::logic_error(\"This transform cannot be performed in-place.\");\n }\n\n if (std::size(v) < m_boundary_filters[0].size())\n {\n std::string msg = \"The input vector must be at least as long as the filter length. \";\n msg += \"The input vector has length = \" + std::to_string(std::size(v)) + \", the filter has length \" + std::to_string(m_boundary_filters[0].size());\n throw std::length_error(msg);\n }\n\n if (std::size(w) < std::size(v))\n {\n std::string msg = \"The output vector (containing the derivative) must be at least as long as the input vector.\";\n msg += \"The output vector has length = \" + std::to_string(std::size(w)) + \", the input vector has length \" + std::to_string(std::size(v));\n throw std::length_error(msg);\n }\n\n if constexpr (order==1)\n {\n for (std::size_t i = 0; i < m_f.size() - 1; ++i)\n {\n auto &bf = m_boundary_filters[i];\n Real dvdt = bf[0] * v[0];\n for (std::size_t j = 1; j < bf.size(); ++j)\n {\n dvdt += bf[j] * v[j];\n }\n w[i] = dvdt;\n }\n\n for(std::size_t i = m_f.size() - 1; i <= std::size(v) - m_f.size(); ++i)\n {\n Real dvdt = m_f[1] * (v[i + 1] - v[i - 1]);\n for (std::size_t j = 2; j < m_f.size(); ++j)\n {\n dvdt += m_f[j] *(v[i + j] - v[i - j]);\n }\n w[i] = dvdt;\n }\n\n\n for(std::size_t i = std::size(v) - m_f.size() + 1; i < std::size(v); ++i)\n {\n int k = std::size(v) - 1 - i;\n auto &f = m_boundary_filters[k];\n Real dvdt = f[0] * v[std::size(v) - 1];;\n for (std::size_t j = 1; j < f.size(); ++j)\n {\n dvdt += f[j] * v[std::size(v) - 1 - j];\n }\n w[i] = -dvdt;\n }\n }\n else if constexpr (order==2)\n {\n // m_f.size() = N+1\n for (std::size_t i = 0; i < m_f.size() - 1; ++i)\n {\n auto &bf = m_boundary_filters[i];\n Real d2vdt2 = 0;\n for (std::size_t j = 0; j < bf.size(); ++j)\n {\n d2vdt2 += bf[j] * v[j];\n }\n w[i] = d2vdt2;\n }\n\n for (std::size_t i = m_f.size() - 1; i <= std::size(v) - m_f.size(); ++i)\n {\n Real d2vdt2 = m_f[0]*v[i];\n for (std::size_t j = 1; j < m_f.size(); ++j)\n {\n d2vdt2 += m_f[j] * (v[i + j] + v[i - j]);\n }\n w[i] = d2vdt2;\n }\n\n for (std::size_t i = std::size(v) - m_f.size() + 1; i < std::size(v); ++i)\n {\n int k = std::size(v) - 1 - i;\n auto &bf = m_boundary_filters[k];\n Real d2vdt2 = bf[0] * v[std::size(v) - 1];\n for (std::size_t j = 1; j < bf.size(); ++j)\n {\n d2vdt2 += bf[j] * v[std::size(v) - 1 - j];\n }\n w[i] = d2vdt2;\n }\n }\n }\n\n template\n RandomAccessContainer operator()(RandomAccessContainer const & v) const\n {\n RandomAccessContainer w(std::size(v));\n this->operator()(v, w);\n return w;\n }\n\n\n // Don't copy; too big.\n discrete_lanczos_derivative( const discrete_lanczos_derivative & ) = delete;\n discrete_lanczos_derivative& operator=(const discrete_lanczos_derivative&) = delete;\n\n // Allow moves:\n discrete_lanczos_derivative(discrete_lanczos_derivative&&) = default;\n discrete_lanczos_derivative& operator=(discrete_lanczos_derivative&&) = default;\n\nprivate:\n std::vector m_f;\n std::vector> m_boundary_filters;\n Real m_dt;\n};\n\n} // namespaces\n#endif\n", "meta": {"hexsha": "4fc7954552d412377df37b4436482bf65f008923", "size": 20395, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/boost/math/differentiation/lanczos_smoothing.hpp", "max_stars_repo_name": "oleg-alexandrov/math", "max_stars_repo_head_hexsha": "2137c31eb8e52129d997a76b893f71c1da0ccc5f", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 233.0, "max_stars_repo_stars_event_min_datetime": "2015-01-12T19:26:01.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-11T09:21:47.000Z", "max_issues_repo_path": "include/boost/math/differentiation/lanczos_smoothing.hpp", "max_issues_repo_name": "oleg-alexandrov/math", "max_issues_repo_head_hexsha": "2137c31eb8e52129d997a76b893f71c1da0ccc5f", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 626.0, "max_issues_repo_issues_event_min_datetime": "2015-02-05T18:12:27.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-20T13:19:18.000Z", "max_forks_repo_path": "include/boost/math/differentiation/lanczos_smoothing.hpp", "max_forks_repo_name": "oleg-alexandrov/math", "max_forks_repo_head_hexsha": "2137c31eb8e52129d997a76b893f71c1da0ccc5f", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 243.0, "max_forks_repo_forks_event_min_datetime": "2015-01-17T17:46:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-07T12:56:26.000Z", "avg_line_length": 34.9828473413, "max_line_length": 159, "alphanum_fraction": 0.461387595, "num_tokens": 5730, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7931059609645724, "lm_q2_score": 0.6297746143530797, "lm_q1q2_score": 0.4994780007075923}} {"text": "/**\n * Conversion routines. Convert from coordinate type to coordinate type\n * via from_type foo = converter()(from_type bar)\n *\n * Copyright 2013 Bruce Ide\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 \"coordinates.hpp\"\n#include \n#include \n\n#ifndef _HPP_CONVERTS\n#define _HPP_CONVERTS\n\nnamespace fr {\n\n namespace coordinates {\n\n template \n struct converter {\n\n };\n\n /***************************************************************\n * Put convert to lat_long bits here\n */\n\n template <>\n struct converter {\n \n // Converting from lat_long to lat_long is kind of odd, but I'll\n // cover the case anyway\n template \n typename std::enable_if::value,lat_long>::type\n\toperator()(const convert_from &c)\n {\n\treturn c;\n }\n\n // ECEF to Latlong\n template \n typename std::enable_if::value,lat_long>::type \n operator()(const convert_from &xyz, const ellipsoid_parameters &e = WGS84_ELLIPSOID, double tolerance = 0.0000000001 )\n {\n\tdouble diff = 2 * tolerance;\n\tdouble t = e.ee * xyz.get_z();\n\tdouble n = 0.0;\n\tdouble nph = 0.0;\n\tdouble sinPhi = 0.0;\n\tdouble lat;\n\tdouble longitude;\n\tdouble alt;\n\n\tlongitude = atan2(xyz.get_y(), xyz.get_x()) * 180 / fr::constants::pi;\n\twhile(diff > tolerance) {\n\t double zT = xyz.get_z() + t;\n\t nph = sqrt(pow(xyz.get_x(), 2) + pow(xyz.get_y(), 2) + pow(zT, 2));\n\t sinPhi = zT / nph;\n\t n = e.ae / sqrt(1 - e.ee * sinPhi * sinPhi);\n\t double told = t;\n\t t = n * e.ee * sinPhi;\n\t diff = fabs(t - told);\n\t}\n\t\n\tlat = asin(sinPhi) * 180 / fr::constants::pi;\n\talt = nph - n;\n\tlat_long retval(lat, longitude, alt);\n\treturn retval;\n }\n\n // ecef_vel to lat_long (Loses velocity information)\n \n template \n typename std::enable_if::value,lat_long>::type\n operator()(const convert_from &c, const ellipsoid_parameters &e = WGS84_ELLIPSOID)\n {\n\tecef interim = converter()(c);\n\tlat_long retval = converter()(interim, e);\n\treturn retval;\n }\n\n // tod_eci_vel to latlong (Loses velocity information)\n template \n typename std::enable_if::value,lat_long>::type\n operator()(const convert_from &c, const double &t, const ellipsoid_parameters e = WGS84_ELLIPSOID)\n {\n\t// Convert from tod_eci to ecef_vel\n\tecef_vel interim = converter()(c,t);\n\t// Then use the function before this one to convert to lat/long\n\tlat_long retval = converter()(interim, e);\n\treturn retval;\n }\n \n };\n\n /*********************************************************\n * Put convert to ECEF bits here\n */\n\n template <>\n struct converter {\n \n // ECEF to ECEF conversion. \n template \n typename std::enable_if::value,ecef>::type\n operator()(const convert_from &c)\n {\n\treturn c;\n }\n\n // latlong to ecef\n template \n typename std::enable_if::value,ecef>::type\n operator()(const convert_from &c, const ellipsoid_parameters &e = WGS84_ELLIPSOID)\n {\n\tdouble x,y,z;\n\tconst double &pi = fr::constants::pi;\n\tdouble slat = sin(c.get_lat() * pi / 180);\n\tdouble clat = cos(c.get_lat() * pi / 180);\n\tdouble slon = sin(c.get_long() * pi / 180);\n\tdouble clon = cos(c.get_long() * pi / 180);\n\tdouble n = e.ae / sqrt(1.0 - e.ee * pow(slat, 2));\n\tx = (n + c.get_alt()) * clat * clon;\n\ty = (n + c.get_alt()) * clat * slon;\n\tz = (n * (1.0 - e.ee) + c.get_alt()) * slat;\n\tecef retval(x,y,z);\n\treturn retval;\n }\n\n // ecef_vel to ecef (loses velocity information)\n template \n typename std::enable_if::value,ecef>::type\n operator()(const convert_from &c)\n {\n\tecef retval(c.get_x(), c.get_y(), c.get_z());\n\treturn retval;\n }\n\n // tod_eci to ecef (Requires time coordinate was measured)\n template \n typename std::enable_if::value,ecef>::type\n operator()(const convert_from &c, const double &at_time)\n {\n\teci_to_ecef conversion_matrix(at_time);\n\tEigen::Vector3d c_vec = c.get_xyz();\n\tEigen::Matrix3d c_mat = conversion_matrix.get();\n\tEigen::Vector3d interim = c_mat * c_vec;\n\tecef retval(interim(0), interim(1), interim(2));\n\treturn retval;\n }\n \n };\n\n\n /**********************************************************\n * Put tod_eci stuff here\n */\n\n template<>\n struct converter {\n \n // ECI to ECI conversion\n\n template \n typename std::enable_if::value,tod_eci>::type\n operator()(const convert_from &c)\n {\n\treturn c;\n }\n\n // ecef to tod_eci (Requires time coordinate was measured)\n template \n typename std::enable_if::value,tod_eci>::type\n operator()(const convert_from &c, const double &time_at)\n {\n\tecef_to_eci conversion_matrix(time_at);\n\tEigen::Vector3d c_vec = c.get_xyz();\n\tEigen::Matrix3d c_mat = conversion_matrix.get();\n\tEigen::Vector3d interim = c_mat * c_vec;\n\ttod_eci retval(interim(0), interim(1), interim(2));\n\treturn retval;\n }\n\n };\n\n /***************************************************************\n * Put ecef_vel stuff here\n */\n\n template<>\n struct converter {\n // ecef_vel to ecef_vel conversion\n template \n typename std::enable_if::value,ecef_vel>::type\n operator()(const convert_from &c)\n {\n\treturn c;\n }\n\n // tod_eci_vel to ecef_vel (requires time component)\n template \n typename std::enable_if::value,ecef_vel>::type\n operator()(const convert_from &c, const double &time_at)\n {\n\tEigen::Matrix vec = c.get_vector();\n\teci_to_ecef cm(time_at);\n\tEigen::Matrix c_mat = cm.get_xyz_vel();\n\tEigen::Matrix interim = c_mat * vec;\n\tecef_vel retval(interim(0), interim(1), interim(2), interim(3), interim(4), interim(5));\n\treturn retval;\n } \n\n };\n\n /********************************************************************\n * Put tod_eci_vel stuff here\n */\n\n template<>\n struct converter {\n \n // From tod_eci_vel to tod_eci_vel\n template \n typename std::enable_if::value,tod_eci_vel>::type\n operator()(const convert_from &c)\n {\n\treturn c;\n }\n\n // from ecef_vel to tod_eci_vel\n template \n typename std::enable_if::value,tod_eci_vel>::type\n operator()(const convert_from &c, const double &t)\n {\n\tecef_to_eci cm(t);\n\tEigen::Matrix vec = c.get_vector();\n\tEigen::Matrix c_mat = cm.get_xyz_vel();\n\tEigen::Matrix interim = c_mat * vec;\n\ttod_eci_vel retval(interim(0), interim(1), interim(2), interim(3), interim(4), interim(5));\n\treturn retval;\t\t\t \n }\n\n };\n \n }\n\n}\n\n#endif\n", "meta": {"hexsha": "15c56101b788ada20faed677a07fe6d4d83f30a5", "size": 8054, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "converts.hpp", "max_stars_repo_name": "FlyingRhenquest/coordinates", "max_stars_repo_head_hexsha": "b6558b7e49e9927b4867456f4ce9fd81ec8bab81", "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": "converts.hpp", "max_issues_repo_name": "FlyingRhenquest/coordinates", "max_issues_repo_head_hexsha": "b6558b7e49e9927b4867456f4ce9fd81ec8bab81", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-03-30T12:28:44.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-10T06:36:53.000Z", "max_forks_repo_path": "converts.hpp", "max_forks_repo_name": "FlyingRhenquest/coordinates", "max_forks_repo_head_hexsha": "b6558b7e49e9927b4867456f4ce9fd81ec8bab81", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2018-02-08T16:17:59.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-14T14:48:59.000Z", "avg_line_length": 30.6235741445, "max_line_length": 124, "alphanum_fraction": 0.6295008691, "num_tokens": 2124, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7931059414036511, "lm_q2_score": 0.6297746074044134, "lm_q1q2_score": 0.49947798287759204}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common.hpp\"\n#include \"fft.hpp\"\n#include \"spectrum_image.hpp\"\n#include \"segment_envelope.hpp\"\n\nspectrum_image::spectrum_image(\n const window_list_t &window,\n const std::vector< int16_t > &audio,\n int x_,\n uint32_t sample_rate_,\n uint32_t resolution_,\n uint32_t scale_,\n int weight,\n unsigned int interval\n) : x( x_ ), resolution( resolution_ ), scale( scale_ ), sample_rate( sample_rate_ ) {\n a = powf( 2.f, float( scale ) + weight );\n b = float( interval ) * float( scale );\n const auto converted = fftref( window, audio, resolution, a, b, x );\n pixels_begin = converted.second.get();\n pixels = converted.second;\n envelope = std::move( converted.first );\n const auto delay_end = std::find_if( envelope.begin(), envelope.end(), []( float v ) { return v != 0.f; } );\n const auto delay_size = std::distance( envelope.begin(), delay_end );\n pixels_begin += delay_size * x;\n envelope.erase( envelope.begin(), delay_end );\n y = envelope.size();\n const auto tail_blank_end = std::find_if( envelope.rbegin(), envelope.rend(), []( float v ) { return v != 0.f; } );\n const auto tail_blank_size = std::distance( envelope.rbegin(), tail_blank_end );\n envelope.resize( envelope.size() - tail_blank_size );\n y = envelope.size();\n std::tie( delay, attack, release ) = segment_envelope( envelope, a, b );\n delay_time = ( a * delay * delay + b * delay ) * tinyfm3::delta;\n attack_time = ( a * attack * attack + b * attack ) * tinyfm3::delta;\n release_time = ( a * release * release + b * release ) * tinyfm3::delta;\n total_time = ( a * envelope.size() * envelope.size() + b * envelope.size() ) * tinyfm3::delta;\n std::cout << __FILE__ << \" \" << __LINE__ << \" \" << delay_time << \" \" << attack_time << \" \" << release_time << \" \" << total_time << std::endl;\n}\nfloat get_distance(\n const spectrum_image &ref,\n const window_list_t &window,\n const std::vector< int16_t > &audio\n) {\n const float a = ref.get_a();\n const float b = ref.get_b();\n const auto converted = fftcomp( ref.get_pixels(), ref.get_height(), window, audio, ref.get_resolution(), a, b, ref.get_width() );\n float delay, attack, release;\n std::tie( delay, attack, release ) = segment_envelope( converted.second, ref.get_a(), ref.get_b() );\n double delay_time = ( a * delay * delay + b * delay ) * tinyfm3::delta;\n double attack_time = ( a * attack * attack + b * attack ) * tinyfm3::delta;\n double release_time = ( a * release * release + b * release ) * tinyfm3::delta;\n double delay_distance = std::abs( ref.get_delay_time() - delay_time );\n double attack_distance = std::abs( ref.get_attack_time() - attack_time );\n double release_distance = std::abs( ref.get_release_time() - release_time );\n// std::cout << delay_distance << \" \" << attack_distance << \" \" << release_distance << std::endl;\n return double( converted.first )/ref.get_width()/ref.get_height() * ( delay_distance * 40.f + attack_distance * 40.f + release_distance * 40.f + 1.f );\n}\n\n", "meta": {"hexsha": "141bb7e7b1f4b9088fdd79a817838d04a30eab7c", "size": 3141, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/spectrum_image.cpp", "max_stars_repo_name": "Fadis/genetic_fm", "max_stars_repo_head_hexsha": "415158b02e2c0dad8fafc81b5762b8889e493f10", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 34.0, "max_stars_repo_stars_event_min_datetime": "2016-10-08T08:55:30.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-17T03:19:54.000Z", "max_issues_repo_path": "src/spectrum_image.cpp", "max_issues_repo_name": "Fadis/genetic_fm", "max_issues_repo_head_hexsha": "415158b02e2c0dad8fafc81b5762b8889e493f10", "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/spectrum_image.cpp", "max_forks_repo_name": "Fadis/genetic_fm", "max_forks_repo_head_hexsha": "415158b02e2c0dad8fafc81b5762b8889e493f10", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-06-21T00:06:30.000Z", "max_forks_repo_forks_event_max_datetime": "2018-06-21T00:06:30.000Z", "avg_line_length": 46.1911764706, "max_line_length": 153, "alphanum_fraction": 0.6711238459, "num_tokens": 842, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278664544911, "lm_q2_score": 0.5660185351961015, "lm_q1q2_score": 0.4994705283867921}} {"text": "#ifndef CHARGE_EV_PHEM_HPP\n#define CHARGE_EV_PHEM_HPP\n\n#include \"common/constant_function.hpp\"\n#include \"common/serialization.hpp\"\n\n#include \"ev/consumption_model.hpp\"\n\n#include \n\n#include \n\nnamespace charge::ev {\nnamespace detail {\n\nenum class PHEMVehicleType : std::int32_t {\n PEUGEOT_ION,\n EV_NO_AUX,\n EV_SPRING,\n EV_SUMMER,\n EV_WINTER,\n INVALID = -1\n};\n\nclass PHEMConsumptionModel : public ConsumptionModel {\n public:\n PHEMConsumptionModel(double speed_parameter, double slope_parameter, double const_parameter)\n : speed_parameter(speed_parameter), slope_parameter(slope_parameter),\n const_parameter(const_parameter) {}\n\n LimitedTradeoffFunction tradeoff_function(const double length, const double slope,\n const double min_speed,\n const double max_speed) const override final {\n assert(min_speed <= max_speed);\n assert(min_speed > 0);\n assert(max_speed < 300);\n\n const double limited_slope = std::max(-10.0, slope*100);\n // Original code has a scaling by 1000, this causes numeric problems.\n // const double a = 1000.0 * length * speed_parameter * (3.6 * 3.6 * length * length);\n // const double b = 0.0;\n // const double c = 1000.0 * length * (slope_parameter * limited_slope + const_parameter);\n const double a = length * speed_parameter * (3.6 * 3.6 * length * length);\n const double b = 0.0;\n const double c = length * (slope_parameter * limited_slope + const_parameter);\n const double min_duration = length * 3.6 / max_speed;\n const double max_duration = length * 3.6 / min_speed;\n assert(min_duration <= max_duration);\n assert(min_duration >= 0);\n\n assert(std::isfinite(a));\n assert(std::isfinite(b));\n assert(std::isfinite(c));\n assert(std::isfinite(min_duration));\n assert(std::isfinite(max_duration));\n\n LimitedTradeoffFunction tradeoff;\n if (a > 0)\n tradeoff = {min_duration, max_duration, common::HyperbolicFunction{a, b, c}};\n else\n tradeoff = {min_duration, max_duration, common::ConstantFunction{c}};\n\n // Only return a tradeoff function of the min and max speed are different\n if (max_speed - min_speed <= 1 || max_duration - min_duration < 1) {\n auto constant_consumption = tradeoff(tradeoff.min_x);\n return LimitedTradeoffFunction{min_duration, min_duration, common::ConstantFunction{constant_consumption}};\n } else {\n return tradeoff;\n }\n }\n\n private:\n double speed_parameter;\n double slope_parameter;\n double const_parameter;\n};\n\nstd::unique_ptr make_consumption_model(PHEMVehicleType type) {\n double speed_parameter, slope_parameter, const_parameter;\n\n switch (type) {\n case PHEMVehicleType::PEUGEOT_ION:\n speed_parameter = 0.00001084948;\n slope_parameter = 0.02863728;\n const_parameter = 0.08052179;\n break;\n case PHEMVehicleType::EV_NO_AUX:\n speed_parameter = 0.00001129197;\n slope_parameter = 0.05127720;\n const_parameter = 0.1247448;\n break;\n case PHEMVehicleType::EV_SPRING:\n speed_parameter = 0.00001105337;\n slope_parameter = 0.05135052;\n const_parameter = 0.1287824;\n break;\n case PHEMVehicleType::EV_SUMMER:\n speed_parameter = 0.000009192936;\n slope_parameter = 0.05194433;\n const_parameter = 0.1605070;\n break;\n case PHEMVehicleType::EV_WINTER:\n speed_parameter = 0.000004730422;\n slope_parameter = 0.05345339;\n const_parameter = 0.2379125;\n break;\n default:\n throw std::runtime_error(\"Unknown vehicle type\");\n }\n\n return std::make_unique(speed_parameter, slope_parameter,\n const_parameter);\n}\n}\n\nstd::unordered_map>\nmake_phem_consumption_models() {\n std::unordered_map> models;\n\n models[\"Peugeot Ion\"] =\n detail::make_consumption_model(detail::PHEMVehicleType::PEUGEOT_ION);\n models[\"EV No Aux\"] =\n detail::make_consumption_model(detail::PHEMVehicleType::EV_NO_AUX);\n models[\"EV Spring\"] =\n detail::make_consumption_model(detail::PHEMVehicleType::EV_SPRING);\n models[\"EV Summer\"] =\n detail::make_consumption_model(detail::PHEMVehicleType::EV_SUMMER);\n models[\"EV Winter\"] =\n detail::make_consumption_model(detail::PHEMVehicleType::EV_WINTER);\n\n return models;\n}\n}\n\n#endif\n", "meta": {"hexsha": "0cb764147902ec6b29ef11784fe8de8d63c4926b", "size": 4748, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/ev/phem.hpp", "max_stars_repo_name": "TheMarex/charge", "max_stars_repo_head_hexsha": "85e35f7a6c8b8c161ecd851124d1363d5a450573", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 13.0, "max_stars_repo_stars_event_min_datetime": "2018-03-09T14:37:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-27T06:56:35.000Z", "max_issues_repo_path": "include/ev/phem.hpp", "max_issues_repo_name": "AlexBlazee/charge", "max_issues_repo_head_hexsha": "85e35f7a6c8b8c161ecd851124d1363d5a450573", "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": "include/ev/phem.hpp", "max_forks_repo_name": "AlexBlazee/charge", "max_forks_repo_head_hexsha": "85e35f7a6c8b8c161ecd851124d1363d5a450573", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2018-04-14T02:27:32.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-13T23:30:44.000Z", "avg_line_length": 34.9117647059, "max_line_length": 119, "alphanum_fraction": 0.6575400168, "num_tokens": 1144, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972684083609, "lm_q2_score": 0.5736784074525098, "lm_q1q2_score": 0.4994428544730137}} {"text": "// This file is part of the dune-gdt project:\n// https://github.com/dune-community/dune-gdt\n// Copyright 2010-2017 dune-gdt developers and contributors. All rights reserved.\n// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)\n// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)\n// with \"runtime exception\" (http://www.dune-project.org/license.html)\n// Authors:\n// Tobias Leibner (2017)\n\n#ifndef DUNE_GDT_HYPERBOLIC_PROBLEMS_MOMENTMODELS_BASISFUNCTIONS_SPHERICALHARMONICS_HH\n#define DUNE_GDT_HYPERBOLIC_PROBLEMS_MOMENTMODELS_BASISFUNCTIONS_SPHERICALHARMONICS_HH\n\n#include \n#include \n\n#include \"base.hh\"\n\nnamespace Dune {\nnamespace GDT {\nnamespace Hyperbolic {\nnamespace Problems {\n\n\n// TODO: use complex arithmetic, currently only usable for Pn Models in 2D, test for only_positive = false\ntemplate \nclass SphericalHarmonics\n : public BasisfunctionsInterface\n{\npublic:\n static const size_t dimDomain = 3;\n static const size_t dimRange = only_positive ? ((order + 1) * (order + 2)) / 2 : (order + 1) * (order + 1);\n static const size_t dimFlux = fluxDim;\n\nprivate:\n typedef BasisfunctionsInterface BaseType;\n\npublic:\n using typename BaseType::DomainType;\n using typename BaseType::RangeType;\n using typename BaseType::MatrixType;\n template \n using VisualizerType = typename BaseType::template VisualizerType;\n\n virtual RangeType evaluate(const DomainType& v) const override\n {\n const auto v_spherical = XT::Common::CoordinateConverter::to_spherical(v);\n return evaluate_in_spherical_coords(v_spherical);\n } // ... evaluate(...)\n\n RangeType evaluate_in_spherical_coords(const FieldVector& coords) const\n {\n const DomainFieldType theta = coords[0];\n const DomainFieldType phi = coords[1];\n RangeType ret(0);\n // TODO: use complex arithmetic, remove real() call\n for (size_t ll = 0; ll <= order; ++ll)\n for (int mm = only_positive ? 0 : -int(ll); mm <= int(ll); ++mm)\n ret[helper::pos(ll, mm)] = boost::math::spherical_harmonic(ll, mm, theta, phi).real();\n return ret;\n } // ... evaluate(...)\n\n virtual RangeType integrated() const override\n {\n RangeType ret(0);\n ret[0] = std::sqrt(4. * M_PI);\n return ret;\n }\n\n virtual MatrixType mass_matrix() const override\n {\n MatrixType M(dimRange, dimRange, 0);\n for (size_t rr = 0; rr < dimRange; ++rr)\n M[rr][rr] = 1;\n return M;\n }\n\n virtual MatrixType mass_matrix_inverse() const override\n {\n return mass_matrix();\n }\n\n virtual FieldVector mass_matrix_with_v() const override\n {\n FieldVector ret(MatrixType(dimRange, dimRange, 0));\n ret[0] = create_Bx();\n ret[1] = create_Bz();\n // if (dimFlux == 3)\n // ret[2] = create_By();\n return ret;\n } // ... mass_matrix_with_v()\n\n template \n VisualizerType visualizer() const\n {\n return [](const DiscreteFunctionType& u_n, const std::string& filename_prefix, const size_t ii) {\n component_visualizer(u_n, filename_prefix, ii, std::sqrt(4 * M_PI));\n };\n }\n\n std::pair calculate_isotropic_distribution(const RangeType& u) const\n {\n RangeType u_iso(0), alpha_iso(0);\n u_iso[0] = u[0];\n alpha_iso[0] = std::log(u[0] / (4. * M_PI));\n return std::make_pair(u_iso, alpha_iso);\n }\n\nprivate:\n static RangeFieldType A_lm(const size_t l, const int m)\n {\n return std::sqrt((l + m) * (l - m) / ((2. * l + 1.) * (2. * l - 1.)));\n }\n\n static RangeFieldType B_lm(const size_t l, const int m)\n {\n return std::sqrt((l + m) * (l + m - 1.) / ((2. * l + 1.) * (2. * l - 1.)));\n }\n\n static MatrixType create_Bx()\n {\n MatrixType Bx(dimRange, dimRange, 0);\n const auto& pos = helper::pos;\n for (size_t l1 = 0; l1 <= order; ++l1) {\n for (int m1 = only_positive ? 0 : -int(l1); size_t(std::abs(m1)) <= l1; ++m1) {\n for (size_t l2 = 0; l2 <= order; ++l2) {\n for (int m2 = -int(l2); size_t(std::abs(m2)) <= l2; ++m2) {\n size_t row = pos(l1, m1);\n size_t col = pos(l2, only_positive ? std::abs(m2) : m2);\n RangeFieldType factor = !only_positive ? 1. : (m2 < 0 ? std::pow(-1., m2) : 1.);\n if (l1 == l2 + 1 && m1 == m2 + 1)\n Bx[row][col] += -0.5 * factor * B_lm(l2 + 1, m2 + 1);\n if (l1 == l2 - 1 && m1 == m2 + 1)\n Bx[row][col] += 0.5 * factor * B_lm(l2, -m2);\n if (l1 == l2 + 1 && m1 == m2 - 1)\n Bx[row][col] += 0.5 * factor * B_lm(l2 + 1, -m2 - 1);\n if (l1 == l2 - 1 && m1 == m2 - 1)\n Bx[row][col] += -0.5 * factor * B_lm(l2, m2);\n } // m2\n } // l2\n } // m1\n } // l1\n return Bx;\n } // ... create_Bx()\n\n // static MatrixType create_By()\n // {\n // MatrixType By(dimRange, dimRange, 0);\n // const auto& pos = helper::pos;\n // for (size_t l1 = 0; l1 <= order; ++l1) {\n // for (int m1 = only_positive ? 0 : -l1; size_t(std::abs(m1)) <= l1; ++m1) {\n // for (size_t l2 = 0; l2 <= order; ++l2) {\n // for (int m2 = -int(l2); size_t(std::abs(m2)) <= l2; ++m2) {\n // size_t row = pos(l1, m1);\n // size_t col = pos(l2, only_positive ? std::abs(m2) : m2);\n // RangeFieldType factor = !only_positive ? 1. : (m2 < 0 ? std::pow(-1., m2) : 1.);\n // if (l1 == l2 + 1 && m1 == m2 + 1)\n // By[row][col] += 0.5 * factor * std::complex(0, 1) * B_lm(l2 + 1, m2 + 1);\n // if (l1 == l2 - 1 && m1 == m2 + 1)\n // By[row][col] += -0.5 * factor * std::complex(0, 1) * B_lm(l2, -m2);\n // if (l1 == l2 + 1 && m1 == m2 - 1)\n // By[row][col] += 0.5 * factor * std::complex(0, 1) * B_lm(l2 + 1, -m2 - 1);\n // if (l1 == l2 - 1 && m1 == m2 - 1)\n // By[row][col] += -0.5 * factor * std::complex(0, 1) * B_lm(l2, m2);\n // } // m2\n // } // l2\n // } // m1\n // } // l1\n // return By;\n // } // ... create_By()\n\n static MatrixType create_Bz()\n {\n MatrixType Bz(dimRange, dimRange, 0);\n const auto& pos = helper::pos;\n for (size_t l1 = 0; l1 <= order; ++l1) {\n for (int m1 = only_positive ? 0. : -int(l1); size_t(std::abs(m1)) <= l1; ++m1) {\n for (size_t l2 = 0; l2 <= order; ++l2) {\n size_t row = pos(l1, m1);\n size_t col = pos(l2, m1); // m1 == m2, else matrix entry is 0\n if (l1 == l2 + 1)\n Bz[row][col] += A_lm(l2 + 1, m1);\n if (l1 == l2 - 1)\n Bz[row][col] += A_lm(l2, m1);\n } // l2\n } // m1\n } // l1\n return Bz;\n }\n\n template \n struct helper\n {\n // Converts a pair (l, m) to a vector index. The vector is ordered by l first, then by m.\n // Each l has 2l+1 values of m, so (l, m) has position\n // (\\sum_{k=0}^{l-1} (2k+1)) + (m+l) = l^2 + m + l\n static size_t pos(const size_t l, const int m)\n {\n return size_t(l * l + m + l);\n }\n };\n\n template \n struct helper\n {\n // Converts a pair (l, m) to a vector index. The vector is ordered by l first, then by m.\n // Each l has l+1 non-negative values of m, so (l, m) has position\n // (\\sum_{k=0}^{l-1} (l+1)) + m = l(l+1)/2 + m\n static size_t pos(const size_t l, const int m)\n {\n return l * (l + 1) / 2 + m;\n }\n };\n}; // class SphericalHarmonics\n\n\ntemplate \nclass RealSphericalHarmonics\n : public BasisfunctionsInterface\n{\npublic:\n static const size_t dimDomain = 3;\n static const size_t dimFlux = fluxDim;\n static const size_t dimRange = only_even ? ((order + 1) * (order + 2)) / 2 : (order + 1) * (order + 1);\n\nprivate:\n typedef BasisfunctionsInterface BaseType;\n\npublic:\n typedef typename Dune::QuadratureRule QuadratureType;\n using typename BaseType::DomainType;\n using typename BaseType::RangeType;\n using typename BaseType::MatrixType;\n template \n using VisualizerType = typename BaseType::template VisualizerType;\n\n virtual RangeType evaluate(const DomainType& v) const override\n {\n const auto v_spherical = XT::Common::CoordinateConverter::to_spherical(v);\n return evaluate_in_spherical_coords(v_spherical);\n } // ... evaluate(...)\n\n RangeType evaluate_in_spherical_coords(const FieldVector& coords) const\n {\n const DomainFieldType theta = coords[0];\n const DomainFieldType phi = coords[1];\n RangeType ret(0);\n for (size_t ll = 0; ll <= order; ++ll)\n for (int mm = -int(ll); mm <= int(ll); ++mm)\n if (!only_even || !((mm + ll) % 2))\n ret[helper::pos(ll, mm)] = evaluate_lm(theta, phi, int(ll), mm);\n return ret;\n } // ... evaluate(...)\n\n virtual RangeType integrated() const override\n {\n RangeType ret(0);\n ret[0] = std::sqrt(4. * M_PI);\n return ret;\n }\n\n virtual MatrixType mass_matrix() const override\n {\n MatrixType M(dimRange, dimRange, 0);\n for (size_t rr = 0; rr < dimRange; ++rr)\n M[rr][rr] = 1;\n return M;\n }\n\n virtual MatrixType mass_matrix_inverse() const override\n {\n return mass_matrix();\n }\n\n virtual FieldVector mass_matrix_with_v() const override\n {\n FieldVector ret(MatrixType(dimRange, dimRange, 0));\n ret[0] = create_Bx();\n ret[1] = create_By();\n if (dimFlux == 3)\n ret[2] = create_Bz();\n return ret;\n } // ... mass_matrix_with_v()\n\n std::pair calculate_isotropic_distribution(const RangeType& u) const\n {\n RangeType u_iso(0), alpha_iso(0);\n u_iso[0] = u[0];\n alpha_iso[0] = std::log(u[0] / std::sqrt(4. * M_PI)) * std::sqrt(4. * M_PI);\n return std::make_pair(u_iso, alpha_iso);\n }\n\n template \n VisualizerType visualizer() const\n {\n return [](const DiscreteFunctionType& u_n, const std::string& filename_prefix, const size_t ii) {\n component_visualizer(u_n, filename_prefix, ii, std::sqrt(4 * M_PI));\n };\n }\n\n RangeFieldType realizability_limiter_max(const RangeType& u, const RangeType& u_bar) const\n {\n return 2 * std::max(u[0], u_bar[0]);\n }\n\nprivate:\n static RangeFieldType A_lm(const size_t l, const int m)\n {\n return std::sqrt((l + m) * (l - m) / ((2. * l + 1.) * (2. * l - 1.)));\n }\n\n static RangeFieldType B_lm(const size_t l, const int m)\n {\n return std::sqrt((l + m) * (l + m - 1.) / ((2. * l + 1.) * (2. * l - 1.)));\n }\n\n static MatrixType create_Bx()\n {\n MatrixType Bx(dimRange, dimRange, 0.);\n const auto& pos = helper::pos;\n for (size_t l1 = 0; l1 <= order; ++l1) {\n for (int m1 = -int(l1); size_t(std::abs(m1)) <= l1; ++m1) {\n for (size_t l2 = 0; l2 <= order; ++l2) {\n for (int m2 = -int(l2); size_t(std::abs(m2)) <= l2; ++m2) {\n if (!only_even || (!((m1 + l1) % 2) && !((m2 + l2) % 2))) {\n if (l1 == l2 - 1 && m1 == m2 - 1 && m2 > 0)\n Bx[pos(l1, m1)][pos(l2, m2)] += 0.5 * std::sqrt(1. + (m2 == 1)) * B_lm(l2, m2);\n if (l1 == l2 + 1 && m1 == m2 - 1 && m2 > 0)\n Bx[pos(l1, m1)][pos(l2, m2)] += -0.5 * std::sqrt(1. + (m2 == 1)) * B_lm(l2 + 1, -m2 + 1);\n if (l1 == l2 - 1 && m1 == m2 + 1 && m2 > 0)\n Bx[pos(l1, m1)][pos(l2, m2)] += -0.5 * B_lm(l2, -m2);\n if (l1 == l2 + 1 && m1 == m2 + 1 && m2 > 0)\n Bx[pos(l1, m1)][pos(l2, m2)] += 0.5 * B_lm(l2 + 1, m2 + 1);\n if (l1 == l2 - 1 && m1 == m2 + 1 && m2 < 0)\n Bx[pos(l1, m1)][pos(l2, m2)] += 0.5 * (1. - (-m2 == 1)) * B_lm(l2, -m2);\n if (l1 == l2 + 1 && m1 == m2 + 1 && m2 < 0)\n Bx[pos(l1, m1)][pos(l2, m2)] += -0.5 * (1. - (-m2 == 1)) * B_lm(l2 + 1, m2 + 1);\n if (l1 == l2 - 1 && m1 == m2 - 1 && m2 < 0)\n Bx[pos(l1, m1)][pos(l2, m2)] += -0.5 * B_lm(l2, m2);\n if (l1 == l2 + 1 && m1 == m2 - 1 && m2 < 0)\n Bx[pos(l1, m1)][pos(l2, m2)] += 0.5 * B_lm(l2 + 1, -m2 + 1);\n if (l1 == l2 - 1 && m1 == 1 && m2 == 0)\n Bx[pos(l1, m1)][pos(l2, m2)] += -1. / std::sqrt(2.) * B_lm(l2, 0);\n if (l1 == l2 + 1 && m1 == 1 && m2 == 0)\n Bx[pos(l1, m1)][pos(l2, m2)] += 1. / std::sqrt(2.) * B_lm(l2 + 1, 1);\n }\n } // m2\n } // l2\n } // m1\n } // l1\n return Bx;\n }\n\n static MatrixType create_By()\n {\n MatrixType By(dimRange, dimRange, 0.);\n const auto& pos = helper::pos;\n for (size_t l1 = 0; l1 <= order; ++l1) {\n for (int m1 = -int(l1); size_t(std::abs(m1)) <= l1; ++m1) {\n for (size_t l2 = 0; l2 <= order; ++l2) {\n for (int m2 = -int(l2); size_t(std::abs(m2)) <= l2; ++m2) {\n if (!only_even || (!((m1 + l1) % 2) && !((m2 + l2) % 2))) {\n if (l1 == l2 + 1 && m1 == -m2 + 1 && m2 > 0)\n By[pos(l1, m1)][pos(l2, m2)] += 0.5 * (1. - (m2 == 1)) * B_lm(l2 + 1, -m2 + 1);\n if (l1 == l2 - 1 && m1 == -m2 + 1 && m2 > 0)\n By[pos(l1, m1)][pos(l2, m2)] += -0.5 * (1. - (m2 == 1)) * B_lm(l2, m2);\n if (l1 == l2 - 1 && m1 == -m2 - 1 && m2 > 0)\n By[pos(l1, m1)][pos(l2, m2)] += -0.5 * B_lm(l2, -m2);\n if (l1 == l2 + 1 && m1 == -m2 - 1 && m2 > 0)\n By[pos(l1, m1)][pos(l2, m2)] += 0.5 * B_lm(l2 + 1, m2 + 1);\n if (l1 == l2 - 1 && m1 == -m2 - 1 && m2 < 0)\n By[pos(l1, m1)][pos(l2, m2)] += 0.5 * std::sqrt(1. + (-m2 == 1)) * B_lm(l2, -m2);\n if (l1 == l2 + 1 && m1 == -m2 - 1 && m2 < 0)\n By[pos(l1, m1)][pos(l2, m2)] += -0.5 * std::sqrt(1. + (-m2 == 1)) * B_lm(l2 + 1, m2 + 1);\n if (l1 == l2 - 1 && m1 == -m2 + 1 && m2 < 0)\n By[pos(l1, m1)][pos(l2, m2)] += 0.5 * B_lm(l2, m2);\n if (l1 == l2 + 1 && m1 == -m2 + 1 && m2 < 0)\n By[pos(l1, m1)][pos(l2, m2)] += -0.5 * B_lm(l2 + 1, -m2 + 1);\n if (l1 == l2 - 1 && m1 == -1 && m2 == 0)\n By[pos(l1, m1)][pos(l2, m2)] += -1. / std::sqrt(2.) * B_lm(l2, 0);\n if (l1 == l2 + 1 && m1 == -1 && m2 == 0)\n By[pos(l1, m1)][pos(l2, m2)] += 1. / std::sqrt(2.) * B_lm(l2 + 1, 1);\n }\n } // m2\n } // l2\n } // m1\n } // l1\n return By;\n } // ... create_By()\n\n static MatrixType create_Bz()\n {\n MatrixType Bz(dimRange, dimRange, 0);\n const auto& pos = helper::pos;\n for (size_t l1 = 0; l1 <= order; ++l1) {\n for (int m1 = -int(l1); size_t(std::abs(m1)) <= l1; ++m1) {\n for (size_t l2 = 0; l2 <= order; ++l2) {\n for (int m2 = -int(l2); size_t(std::abs(m2)) <= l2; ++m2) {\n if (!only_even || (!((m1 + l1) % 2) && !((m2 + l2) % 2))) {\n if (m1 == m2 && l1 == l2 + 1)\n Bz[pos(l1, m1)][pos(l2, m2)] += A_lm(l2 + 1, m2);\n if (m1 == m2 && l1 == l2 - 1)\n Bz[pos(l1, m1)][pos(l2, m2)] += A_lm(l2, m2);\n }\n } // m2\n } // l2\n } // m1\n } // l1\n return Bz;\n } // ... create_Bz()\n\n template \n struct helper\n {\n // Converts a pair (l, m) to a vector index. The vector is ordered by l first, then by m.\n // Each l has 2l+1 values of m, so (l, m) has position\n // (\\sum_{k=0}^{l-1} (2k+1)) + (m+l) = l^2 + m + l\n static size_t pos(const size_t l, const int m)\n {\n return size_t(l * l + m + l);\n }\n };\n\n template \n struct helper\n {\n // Converts a pair (l, m) to a vector index. The vector is ordered by l first, then by m.\n // Each l has l+1 values of m (as only m s.t. m+l is even are considered), so (l, m) has position\n // (\\sum_{k=0}^{l-1} (k+1)) + (m+l)/2 = l(l+1)/2 + (l+m)/2\n static size_t pos(const int l, const int m)\n {\n return size_t(l * (l + 1) / 2 + (m + l) / 2);\n }\n };\n\n // Notation from Garrett, Hauck, \"A Comparison of Moment Closures for Linear Kinetic Transport Equations: The Line\n // Source Benchmark\",\n // http://www.tandfonline.com/doi/full/10.1080/00411450.2014.910226?src=recsys&, Section 4.1\n RangeFieldType N_lm(const int l, const int m) const\n {\n assert(l >= 0 && m >= 0 && m <= l);\n return std::sqrt((2. * l + 1.) * XT::Common::factorial(l - m) / (XT::Common::factorial(l + m) * 4. * M_PI));\n }\n\n RangeFieldType evaluate_lm(const DomainFieldType theta, const DomainFieldType phi, const int l, const int m) const\n {\n const auto cos_theta = std::cos(theta);\n assert(l >= 0 && std::abs(m) <= l);\n if (m < 0)\n return std::sqrt(2) * N_lm(l, -m) * boost::math::legendre_p(l, -m, cos_theta) * std::sin(-m * phi);\n else if (m == 0)\n return N_lm(l, 0) * boost::math::legendre_p(l, 0, cos_theta);\n else\n return std::sqrt(2) * N_lm(l, m) * boost::math::legendre_p(l, m, cos_theta) * std::cos(m * phi);\n }\n}; // class RealSphericalHarmonics\n\n\n} // namespace Problems\n} // namespace Hyperbolic\n} // namespace GDT\n} // namespace Dune\n\n#endif // DUNE_GDT_HYPERBOLIC_PROBLEMS_MOMENTMODELS_BASISFUNCTIONS_SPHERICALHARMONICS_HH\n", "meta": {"hexsha": "423b6b2908466228a379a6e42e3ef8ef1ea8d17d", "size": 18704, "ext": "hh", "lang": "C++", "max_stars_repo_path": "dune/gdt/test/hyperbolic/problems/momentmodels/basisfunctions/spherical_harmonics.hh", "max_stars_repo_name": "tobiasleibner/dune-gdt", "max_stars_repo_head_hexsha": "5d3dc6c7f5fd66db78ebb294d7ee4803f8e0bf5b", "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": "dune/gdt/test/hyperbolic/problems/momentmodels/basisfunctions/spherical_harmonics.hh", "max_issues_repo_name": "tobiasleibner/dune-gdt", "max_issues_repo_head_hexsha": "5d3dc6c7f5fd66db78ebb294d7ee4803f8e0bf5b", "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": "dune/gdt/test/hyperbolic/problems/momentmodels/basisfunctions/spherical_harmonics.hh", "max_forks_repo_name": "tobiasleibner/dune-gdt", "max_forks_repo_head_hexsha": "5d3dc6c7f5fd66db78ebb294d7ee4803f8e0bf5b", "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": 39.4599156118, "max_line_length": 116, "alphanum_fraction": 0.5324529512, "num_tokens": 6476, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677506936878, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.49935899162515945}} {"text": "#include \"OGR.h\"\n#include \n#include \n#include \n\n// ----------------------------------------------------------------------\n/*!\n * \\brief Calculate area in m^2 for a geography\n *\n * Refs: Some algorithms for polygons on a sphere\n * http://hdl.handle.net/2014/40409\n *\n * https://trac.osgeo.org/openlayers/browser/trunk/openlayers/lib/OpenLayers/Geometry/LinearRing.js\n *\n * Note: The algorithm returns a positive number for clockwise rings.\n */\n// ----------------------------------------------------------------------\n\ndouble geographic_area(const OGRLineString *theGeom)\n{\n try\n {\n double area = 0;\n\n std::size_t npoints = theGeom->getNumPoints();\n\n for (std::size_t i = 0; i < npoints - 1; i++)\n {\n double x1 = theGeom->getX(i) * boost::math::double_constants::degree;\n double y1 = theGeom->getY(i) * boost::math::double_constants::degree;\n double x2 = theGeom->getX(i + 1) * boost::math::double_constants::degree;\n double y2 = theGeom->getY(i + 1) * boost::math::double_constants::degree;\n\n area += (x2 - x1) * (2 + sin(y1) + sin(y2));\n }\n area *= 6378137.0 * 6378137.0 / 2.0;\n\n return std::abs(area);\n }\n catch (...)\n {\n throw Fmi::Exception::Trace(BCP, \"Operation failed!\");\n }\n}\n\ndouble geographic_area(const OGRLinearRing *theGeom)\n{\n try\n {\n return geographic_area(static_cast(theGeom));\n }\n catch (...)\n {\n throw Fmi::Exception::Trace(BCP, \"Operation failed!\");\n }\n}\n\n// ----------------------------------------------------------------------\n/*!\n * \\brief get_Area substitute for OGRLineString copied from OGRLinearRing::get_Area()\n *\n * The area is computed according to Green's Theorem:\n *\n * Area is \"Sum(x(i)*(y(i+1) - y(i-1)))/2\" for i = 0 to pointCount-1,\n * assuming the last point is a duplicate of the first.\n *\n */\n// ----------------------------------------------------------------------\n\ndouble metric_area(const OGRLineString *theGeom)\n{\n try\n {\n std::size_t npoints = theGeom->getNumPoints();\n if (npoints < 2)\n return 0;\n\n double area = theGeom->getX(0) * (theGeom->getY(1) - theGeom->getY(npoints - 1));\n\n for (std::size_t i = 1; i < npoints - 1; i++)\n area += theGeom->getX(i) * (theGeom->getY(i + 1) - theGeom->getY(i - 1));\n\n area += theGeom->getX(npoints - 1) * (theGeom->getY(0) - theGeom->getY(npoints - 2));\n\n return 0.5 * std::abs(area);\n }\n catch (...)\n {\n throw Fmi::Exception::Trace(BCP, \"Operation failed!\");\n }\n}\n\n// ----------------------------------------------------------------------\n/*!\n * \\brief Despeckle OGR geometry\n */\n// ----------------------------------------------------------------------\n\nOGRPolygon *despeckle_polygon(const OGRPolygon *theGeom, double theLimit, bool theGeogFlag)\n{\n try\n {\n // Quick exit if the exterior is too small\n\n const auto *exterior = theGeom->getExteriorRing();\n double area = (theGeogFlag ? geographic_area(exterior) : exterior->get_Area());\n\n if (area < theLimit)\n return nullptr;\n\n // We have at least a valid exterior\n\n auto *out = new OGRPolygon;\n out->addRingDirectly(dynamic_cast(exterior->clone()));\n\n // Remove too small holes too\n\n for (int i = 0, n = theGeom->getNumInteriorRings(); i < n; ++i)\n {\n const auto *hole = theGeom->getInteriorRing(i);\n area = (theGeogFlag ? geographic_area(hole) : hole->get_Area());\n if (area >= theLimit)\n out->addRingDirectly(dynamic_cast(hole->clone()));\n }\n\n return out;\n }\n catch (...)\n {\n throw Fmi::Exception::Trace(BCP, \"Operation failed!\");\n }\n}\n\n// ----------------------------------------------------------------------\n/*!\n * \\brief Despeckle OGR geometry\n */\n// ----------------------------------------------------------------------\n\nOGRLineString *despeckle_linestring(const OGRLineString *theGeom, double theLimit, bool theGeogFlag)\n{\n try\n {\n if (theGeom == nullptr || theGeom->IsEmpty() != 0)\n return nullptr;\n\n if (!theGeom->get_IsClosed())\n return dynamic_cast(theGeom->clone());\n\n // Despeckle closed linestrings only\n\n // TODO: Old GDAL does not have get_Area for linestrings\n // double area = (theGeogFlag ? geographic_area(theGeom) : geom->get_Area());\n double area = (theGeogFlag ? geographic_area(theGeom) : metric_area(theGeom));\n\n if (area < theLimit)\n return nullptr;\n\n return dynamic_cast(theGeom->clone());\n }\n catch (...)\n {\n throw Fmi::Exception::Trace(BCP, \"Operation failed!\");\n }\n}\n\n// ----------------------------------------------------------------------\n/*!\n * \\brief Despeckle OGR geometry\n */\n// ----------------------------------------------------------------------\n\nOGRPoint *despeckle_point(const OGRPoint *theGeom)\n{\n try\n {\n if (theGeom == nullptr || theGeom->IsEmpty() != 0)\n return nullptr;\n\n return dynamic_cast(theGeom->clone());\n }\n catch (...)\n {\n throw Fmi::Exception::Trace(BCP, \"Operation failed!\");\n }\n}\n\n// ----------------------------------------------------------------------\n/*!\n * \\brief Despeckle OGR geometry\n */\n// ----------------------------------------------------------------------\n\nOGRMultiPoint *despeckle_multipoint(const OGRMultiPoint *theGeom)\n{\n try\n {\n if (theGeom == nullptr || theGeom->IsEmpty() != 0)\n return nullptr;\n\n return dynamic_cast(theGeom->clone());\n }\n catch (...)\n {\n throw Fmi::Exception::Trace(BCP, \"Operation failed!\");\n }\n}\n\n// ----------------------------------------------------------------------\n/*!\n * \\brief Despeckle OGR geometry\n */\n// ----------------------------------------------------------------------\n\nOGRMultiLineString *despeckle_multilinestring(const OGRMultiLineString *theGeom,\n double theLimit,\n bool theGeogFlag)\n{\n try\n {\n if (theGeom == nullptr || theGeom->IsEmpty() != 0)\n return nullptr;\n ;\n\n auto *out = new OGRMultiLineString();\n\n for (int i = 0, n = theGeom->getNumGeometries(); i < n; ++i)\n {\n auto *geom = despeckle_linestring(\n dynamic_cast(theGeom->getGeometryRef(i)), theLimit, theGeogFlag);\n if (geom != nullptr)\n out->addGeometryDirectly(geom);\n }\n\n if (out->IsEmpty() == 0)\n return out;\n\n delete out;\n return nullptr;\n }\n catch (...)\n {\n throw Fmi::Exception::Trace(BCP, \"Operation failed!\");\n }\n}\n\n// ----------------------------------------------------------------------\n/*!\n * \\brief Despeckle OGR geometry\n */\n// ----------------------------------------------------------------------\n\nOGRMultiPolygon *despeckle_multipolygon(const OGRMultiPolygon *theGeom,\n double theLimit,\n bool theGeogFlag)\n{\n try\n {\n if (theGeom == nullptr || theGeom->IsEmpty() != 0)\n return nullptr;\n\n auto *out = new OGRMultiPolygon();\n\n for (int i = 0, n = theGeom->getNumGeometries(); i < n; ++i)\n {\n auto *geom = despeckle_polygon(\n dynamic_cast(theGeom->getGeometryRef(i)), theLimit, theGeogFlag);\n if (geom != nullptr)\n out->addGeometryDirectly(geom);\n }\n\n if (out->IsEmpty() == 0)\n return out;\n\n delete out;\n return nullptr;\n }\n catch (...)\n {\n throw Fmi::Exception::Trace(BCP, \"Operation failed!\");\n }\n}\n\n// ----------------------------------------------------------------------\n/*!\n * \\brief Despeckle OGR geometry\n */\n// ----------------------------------------------------------------------\n\n// Needed since two functions call each other\n\nOGRGeometry *despeckle_geom(const OGRGeometry *theGeom, double theLimit, bool theGeogFlag);\n\nOGRGeometryCollection *despeckle_geometrycollection(const OGRGeometryCollection *theGeom,\n double theLimit,\n bool theGeogFlag)\n{\n try\n {\n if (theGeom == nullptr || theGeom->IsEmpty() != 0)\n return nullptr;\n\n auto *out = new OGRGeometryCollection;\n\n for (int i = 0, n = theGeom->getNumGeometries(); i < n; ++i)\n {\n auto *geom = despeckle_geom(theGeom->getGeometryRef(i), theLimit, theGeogFlag);\n if (geom != nullptr)\n out->addGeometryDirectly(geom);\n }\n\n if (out->IsEmpty() == 0)\n return out;\n\n delete out;\n return nullptr;\n }\n catch (...)\n {\n throw Fmi::Exception::Trace(BCP, \"Operation failed!\");\n }\n}\n\n// ----------------------------------------------------------------------\n/*!\n * \\brief Despeckle OGR geometry to output geometry\n */\n// ----------------------------------------------------------------------\n\nOGRGeometry *despeckle_geom(const OGRGeometry *theGeom, double theLimit, bool theGeogFlag)\n{\n try\n {\n OGRwkbGeometryType id = theGeom->getGeometryType();\n\n switch (id)\n {\n case wkbPoint:\n return despeckle_point(dynamic_cast(theGeom));\n case wkbLineString:\n return despeckle_linestring(\n dynamic_cast(theGeom), theLimit, theGeogFlag);\n case wkbPolygon:\n return despeckle_polygon(dynamic_cast(theGeom), theLimit, theGeogFlag);\n case wkbMultiPoint:\n return despeckle_multipoint(dynamic_cast(theGeom));\n case wkbMultiLineString:\n return despeckle_multilinestring(\n dynamic_cast(theGeom), theLimit, theGeogFlag);\n case wkbMultiPolygon:\n return despeckle_multipolygon(\n dynamic_cast(theGeom), theLimit, theGeogFlag);\n case wkbGeometryCollection:\n return despeckle_geometrycollection(\n dynamic_cast(theGeom), theLimit, theGeogFlag);\n case wkbLinearRing:\n throw Fmi::Exception::Trace(BCP, \"Direct despeckling of LinearRings is not supported\");\n case wkbNone:\n throw Fmi::Exception::Trace(\n BCP, \"Encountered a 'none' geometry component when despeckling a geometry\");\n default:\n throw Fmi::Exception::Trace(\n BCP, \"Encountered an unknown geometry component when clipping polygons\");\n }\n\n // NOT REACHED\n return nullptr;\n }\n catch (...)\n {\n throw Fmi::Exception::Trace(BCP, \"Operation failed!\");\n }\n}\n\n// ----------------------------------------------------------------------\n/*!\n * \\brief Despeckle a geometry so that small polygons are removed\n *\n * \\return Empty GeometryCollection if the result is empty\n */\n// ----------------------------------------------------------------------\n\nOGRGeometry *Fmi::OGR::despeckle(const OGRGeometry &theGeom, double theAreaLimit)\n{\n try\n {\n // Area calculations for geographies must be done by ourselves, OGR\n // does it in the native system and hence would produce square degrees.\n\n OGRSpatialReference *crs = theGeom.getSpatialReference();\n bool geographic = (crs != nullptr ? (crs->IsGeographic() != 0) : false);\n\n // Actual despeckling\n\n auto *geom =\n despeckle_geom(&theGeom, theAreaLimit * 1000 * 1000, geographic); // from m^2 to km^2\n\n if (geom != nullptr)\n geom->assignSpatialReference(theGeom.getSpatialReference()); // SR is ref. counted\n\n return geom;\n }\n catch (...)\n {\n throw Fmi::Exception::Trace(BCP, \"Operation failed!\");\n }\n}\n", "meta": {"hexsha": "8bbe1bb27028c4203ce7775fbba4f1af1d06e9fa", "size": 11563, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "gis/OGR-despeckle.cpp", "max_stars_repo_name": "fmidev/smartmet-library-gis", "max_stars_repo_head_hexsha": "3fd5e7ede8f04e262d7de3f884fb575d98ae956d", "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": "gis/OGR-despeckle.cpp", "max_issues_repo_name": "fmidev/smartmet-library-gis", "max_issues_repo_head_hexsha": "3fd5e7ede8f04e262d7de3f884fb575d98ae956d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2017-03-01T10:15:38.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-11T10:53:26.000Z", "max_forks_repo_path": "gis/OGR-despeckle.cpp", "max_forks_repo_name": "fmidev/smartmet-library-gis", "max_forks_repo_head_hexsha": "3fd5e7ede8f04e262d7de3f884fb575d98ae956d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2017-09-16T15:14:06.000Z", "max_forks_repo_forks_event_max_datetime": "2017-09-16T15:14:06.000Z", "avg_line_length": 28.3406862745, "max_line_length": 105, "alphanum_fraction": 0.5396523394, "num_tokens": 2799, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677506936878, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.49935899162515945}} {"text": "//=======================================================================\r\n// Copyright 2007 Aaron Windsor\r\n//\r\n// Distributed under the Boost Software License, Version 1.0. (See\r\n// accompanying file LICENSE_1_0.txt or copy at\r\n// http://www.boost.org/LICENSE_1_0.txt)\r\n//=======================================================================\r\n#ifndef __IS_KURATOWSKI_SUBGRAPH_HPP__\r\n#define __IS_KURATOWSKI_SUBGRAPH_HPP__\r\n\r\n#include \r\n#include //for next/prior\r\n#include //for tie\r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n#include \r\n#include \r\n#include \r\n\r\n\r\n\r\nnamespace boost\r\n{\r\n \r\n namespace detail\r\n {\r\n\r\n template \r\n Graph make_K_5()\r\n {\r\n typename graph_traits::vertex_iterator vi, vi_end, inner_vi;\r\n Graph K_5(5);\r\n for(tie(vi,vi_end) = vertices(K_5); vi != vi_end; ++vi)\r\n for(inner_vi = next(vi); inner_vi != vi_end; ++inner_vi)\r\n add_edge(*vi, *inner_vi, K_5);\r\n return K_5;\r\n }\r\n\r\n\r\n template \r\n Graph make_K_3_3()\r\n {\r\n typename graph_traits::vertex_iterator \r\n vi, vi_end, bipartition_start, inner_vi;\r\n Graph K_3_3(6);\r\n bipartition_start = next(next(next(vertices(K_3_3).first)));\r\n for(tie(vi, vi_end) = vertices(K_3_3); vi != bipartition_start; ++vi)\r\n for(inner_vi= bipartition_start; inner_vi != vi_end; ++inner_vi)\r\n add_edge(*vi, *inner_vi, K_3_3);\r\n return K_3_3;\r\n }\r\n\r\n\r\n template \r\n void contract_edge(AdjacencyList& neighbors, Vertex u, Vertex v)\r\n {\r\n // Remove u from v's neighbor list\r\n neighbors[v].erase(std::remove(neighbors[v].begin(), \r\n neighbors[v].end(), u\r\n ), \r\n neighbors[v].end()\r\n );\r\n \r\n // Replace any references to u with references to v\r\n typedef typename AdjacencyList::value_type::iterator \r\n adjacency_iterator_t;\r\n \r\n adjacency_iterator_t u_neighbor_end = neighbors[u].end();\r\n for(adjacency_iterator_t u_neighbor_itr = neighbors[u].begin();\r\n u_neighbor_itr != u_neighbor_end; ++u_neighbor_itr\r\n )\r\n {\r\n Vertex u_neighbor(*u_neighbor_itr);\r\n std::replace(neighbors[u_neighbor].begin(), \r\n neighbors[u_neighbor].end(), u, v\r\n );\r\n }\r\n \r\n // Remove v from u's neighbor list\r\n neighbors[u].erase(std::remove(neighbors[u].begin(), \r\n neighbors[u].end(), v\r\n ), \r\n neighbors[u].end()\r\n );\r\n \r\n // Add everything in u's neighbor list to v's neighbor list\r\n std::copy(neighbors[u].begin(), \r\n neighbors[u].end(), \r\n std::back_inserter(neighbors[v])\r\n );\r\n \r\n // Clear u's neighbor list\r\n neighbors[u].clear();\r\n\r\n }\r\n\r\n enum target_graph_t { tg_k_3_3, tg_k_5};\r\n\r\n } // namespace detail\r\n\r\n\r\n\r\n\r\n template \r\n bool is_kuratowski_subgraph(const Graph& g,\r\n ForwardIterator begin, \r\n ForwardIterator end, \r\n VertexIndexMap vm\r\n )\r\n {\r\n\r\n typedef typename graph_traits::vertex_descriptor vertex_t;\r\n typedef typename graph_traits::vertex_iterator vertex_iterator_t;\r\n typedef typename graph_traits::edge_descriptor edge_t;\r\n typedef typename graph_traits::edges_size_type e_size_t;\r\n typedef typename graph_traits::vertices_size_type v_size_t;\r\n typedef typename std::vector v_list_t;\r\n typedef typename v_list_t::iterator v_list_iterator_t;\r\n typedef iterator_property_map\r\n ::iterator, VertexIndexMap> \r\n vertex_to_v_list_map_t;\r\n\r\n typedef adjacency_list small_graph_t;\r\n\r\n detail::target_graph_t target_graph = detail::tg_k_3_3; //unless we decide otherwise later\r\n\r\n static small_graph_t K_5(detail::make_K_5());\r\n\r\n static small_graph_t K_3_3(detail::make_K_3_3());\r\n\r\n v_size_t n_vertices(num_vertices(g));\r\n v_size_t max_num_edges(3*n_vertices - 5);\r\n\r\n std::vector neighbors_vector(n_vertices);\r\n vertex_to_v_list_map_t neighbors(neighbors_vector.begin(), vm);\r\n\r\n e_size_t count = 0;\r\n for(ForwardIterator itr = begin; itr != end; ++itr)\r\n {\r\n\r\n if (count++ > max_num_edges)\r\n return false;\r\n\r\n edge_t e(*itr);\r\n vertex_t u(source(e,g));\r\n vertex_t v(target(e,g));\r\n\r\n neighbors[u].push_back(v);\r\n neighbors[v].push_back(u);\r\n\r\n }\r\n\r\n\r\n for(v_size_t max_size = 2; max_size < 5; ++max_size)\r\n {\r\n\r\n vertex_iterator_t vi, vi_end;\r\n for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)\r\n {\r\n vertex_t v(*vi);\r\n\r\n //a hack to make sure we don't contract the middle edge of a path\r\n //of four degree-3 vertices\r\n if (max_size == 4 && neighbors[v].size() == 3)\r\n {\r\n if (neighbors[neighbors[v][0]].size() +\r\n neighbors[neighbors[v][1]].size() +\r\n neighbors[neighbors[v][2]].size()\r\n < 11 // so, it has two degree-3 neighbors\r\n )\r\n continue;\r\n }\r\n\r\n while (neighbors[v].size() > 0 && neighbors[v].size() < max_size)\r\n {\r\n // Find one of v's neighbors u such that that v and u\r\n // have no neighbors in common. We'll look for such a \r\n // neighbor with a naive cubic-time algorithm since the \r\n // max size of any of the neighbor sets we'll consider \r\n // merging is 3\r\n \r\n bool neighbor_sets_intersect = false;\r\n \r\n vertex_t min_u = graph_traits::null_vertex();\r\n vertex_t u;\r\n v_list_iterator_t v_neighbor_end = neighbors[v].end();\r\n for(v_list_iterator_t v_neighbor_itr = neighbors[v].begin();\r\n v_neighbor_itr != v_neighbor_end; \r\n ++v_neighbor_itr\r\n )\r\n {\r\n neighbor_sets_intersect = false;\r\n u = *v_neighbor_itr;\r\n v_list_iterator_t u_neighbor_end = neighbors[u].end();\r\n for(v_list_iterator_t u_neighbor_itr = \r\n neighbors[u].begin();\r\n u_neighbor_itr != u_neighbor_end && \r\n !neighbor_sets_intersect; \r\n ++u_neighbor_itr\r\n )\r\n {\r\n for(v_list_iterator_t inner_v_neighbor_itr = \r\n neighbors[v].begin();\r\n inner_v_neighbor_itr != v_neighbor_end; \r\n ++inner_v_neighbor_itr\r\n )\r\n {\r\n if (*u_neighbor_itr == *inner_v_neighbor_itr)\r\n {\r\n neighbor_sets_intersect = true;\r\n break;\r\n }\r\n }\r\n \r\n }\r\n if (!neighbor_sets_intersect &&\r\n (min_u == graph_traits::null_vertex() || \r\n neighbors[u].size() < neighbors[min_u].size())\r\n )\r\n {\r\n min_u = u;\r\n }\r\n \r\n }\r\n\r\n if (min_u == graph_traits::null_vertex())\r\n // Exited the loop without finding an appropriate neighbor of\r\n // v, so v must be a lost cause. Move on to other vertices.\r\n break;\r\n else\r\n u = min_u;\r\n\r\n detail::contract_edge(neighbors, u, v);\r\n\r\n }//end iteration over v's neighbors\r\n\r\n }//end iteration through vertices v\r\n\r\n if (max_size == 3)\r\n {\r\n // check to see whether we should go on to find a K_5\r\n for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)\r\n if (neighbors[*vi].size() == 4)\r\n {\r\n target_graph = detail::tg_k_5;\r\n break;\r\n }\r\n\r\n if (target_graph == detail::tg_k_3_3)\r\n break;\r\n }\r\n \r\n }//end iteration through max degree 2,3, and 4\r\n\r\n \r\n //Now, there should only be 5 or 6 vertices with any neighbors. Find them.\r\n \r\n v_list_t main_vertices;\r\n vertex_iterator_t vi, vi_end;\r\n \r\n for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)\r\n {\r\n if (!neighbors[*vi].empty())\r\n main_vertices.push_back(*vi);\r\n }\r\n \r\n // create a graph isomorphic to the contracted graph to test \r\n // against K_5 and K_3_3\r\n small_graph_t contracted_graph(main_vertices.size());\r\n std::map::vertex_descriptor> \r\n contracted_vertex_map;\r\n \r\n typename v_list_t::iterator itr, itr_end;\r\n itr_end = main_vertices.end();\r\n typename graph_traits::vertex_iterator \r\n si = vertices(contracted_graph).first;\r\n \r\n for(itr = main_vertices.begin(); itr != itr_end; ++itr, ++si)\r\n {\r\n contracted_vertex_map[*itr] = *si;\r\n }\r\n\r\n typename v_list_t::iterator jtr, jtr_end;\r\n for(itr = main_vertices.begin(); itr != itr_end; ++itr)\r\n {\r\n jtr_end = neighbors[*itr].end();\r\n for(jtr = neighbors[*itr].begin(); jtr != jtr_end; ++jtr)\r\n {\r\n if (get(vm,*itr) < get(vm,*jtr))\r\n {\r\n add_edge(contracted_vertex_map[*itr],\r\n contracted_vertex_map[*jtr],\r\n contracted_graph\r\n );\r\n }\r\n }\r\n }\r\n \r\n if (target_graph == detail::tg_k_5)\r\n {\r\n return isomorphism(K_5,contracted_graph);\r\n }\r\n else //target_graph == tg_k_3_3\r\n {\r\n return isomorphism(K_3_3,contracted_graph);\r\n }\r\n \r\n \r\n }\r\n\r\n\r\n\r\n\r\n\r\n template \r\n bool is_kuratowski_subgraph(const Graph& g, \r\n ForwardIterator begin, \r\n ForwardIterator end\r\n )\r\n {\r\n return is_kuratowski_subgraph(g, begin, end, get(vertex_index,g));\r\n }\r\n\r\n\r\n\r\n \r\n}\r\n\r\n#endif //__IS_KURATOWSKI_SUBGRAPH_HPP__\r\n", "meta": {"hexsha": "a9509649f0c9c050122e1b3d8560d30169c21443", "size": 11281, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "trunk/win/Source/Includes/Boost/graph/is_kuratowski_subgraph.hpp", "max_stars_repo_name": "dyzmapl/BumpTop", "max_stars_repo_head_hexsha": "1329ea41411c7368516b942d19add694af3d602f", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 460.0, "max_stars_repo_stars_event_min_datetime": "2016-01-13T12:49:34.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-20T04:10:40.000Z", "max_issues_repo_path": "trunk/win/Source/Includes/Boost/graph/is_kuratowski_subgraph.hpp", "max_issues_repo_name": "dyzmapl/BumpTop", "max_issues_repo_head_hexsha": "1329ea41411c7368516b942d19add694af3d602f", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 24.0, "max_issues_repo_issues_event_min_datetime": "2016-11-07T04:59:49.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-14T06:34:12.000Z", "max_forks_repo_path": "trunk/win/Source/Includes/Boost/graph/is_kuratowski_subgraph.hpp", "max_forks_repo_name": "dyzmapl/BumpTop", "max_forks_repo_head_hexsha": "1329ea41411c7368516b942d19add694af3d602f", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 148.0, "max_forks_repo_forks_event_min_datetime": "2016-01-17T03:16:43.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-17T12:20:36.000Z", "avg_line_length": 33.8768768769, "max_line_length": 95, "alphanum_fraction": 0.5099725202, "num_tokens": 2352, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7662936430859598, "lm_q2_score": 0.6513548782017745, "lm_q1q2_score": 0.4991291025590494}} {"text": "//============================================================================\n// Daniel J. Greenhoe\n// normed linear space R^2\n//=============================================================================\n//=====================================\n// headers\n//=====================================\n#include \n#include \n#include \n#include \n#include // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89325\n#include \"r1.h\"\n#include \"r4.h\"\ntypedef Eigen::Matrix< double, 4, 1 > Vector4d;\n\n//=====================================\n// oquad\n//=====================================\n//-----------------------------------------------------------------------------\n// oquad constructors\n//-----------------------------------------------------------------------------\noquad::oquad(void)\n{\n xx.at(0) = 0.0;\n xx.at(1) = 0.0;\n xx.at(2) = 0.0;\n xx.at(3) = 0.0;\n}\n\noquad::oquad(double u0, double u1, double u2, double u3)\n{\n xx.at(0) = u0;\n xx.at(1) = u1;\n xx.at(2) = u2;\n xx.at(3) = u3;\n}\n\noquad::oquad(double u)\n{\n xx.at(0) = u;\n xx.at(1) = u;\n xx.at(2) = u;\n xx.at(3) = u;\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief oquad put member functions\n//-----------------------------------------------------------------------------\nvoid oquad::put(double u)\n{\n xx.at(0) = u;\n xx.at(1) = u;\n xx.at(2) = u;\n xx.at(3) = u;\n}\n\nvoid oquad::put(oquad u)\n{\n xx.at(0) = u.get(0);\n xx.at(1) = u.get(1);\n xx.at(2) = u.get(2);\n xx.at(3) = u.get(3);\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief Write values to oquad\n//-----------------------------------------------------------------------------\nvoid oquad::put(double u0, double u1, double u2, double u3)\n{\n xx.at(0) = u0;\n xx.at(1) = u1;\n xx.at(2) = u2;\n xx.at(3) = u3;\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief Write values to oquad\n//-----------------------------------------------------------------------------\nvoid oquad::put(int n,double u)\n{\n xx.at(n) = u;\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief return the 4-tuple value\n//-----------------------------------------------------------------------------\noquad oquad::get(void)\n{\n oquad u;\n u.put( 0, get1() );\n u.put( 1, get2() );\n u.put( 2, get3() );\n u.put( 3, get4() );\n return u;\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief return the minimum element of the 4 tupple\n//-----------------------------------------------------------------------------\ndouble oquad::min(void) const\n{\n const Eigen::Map< const Vector4d > a( getdata() );\n const double minVal = a.minCoeff();\n return minVal;\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief return the maximum element of the 4 tupple\n//-----------------------------------------------------------------------------\ndouble oquad::max(void) const\n{\n const Eigen::Map< const Vector4d > a( getdata() );\n const double maxVal = a.maxCoeff();\n return maxVal;\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief print the tuple\n//-----------------------------------------------------------------------------\nvoid oquad::list(const char *str1, const char *str2) const\n{\n if(strlen(str1)!=0)printf(\"%s\",str1);\n putchar('(');\n printf(\"%9.6lf,\", get1() );\n printf(\"%9.6lf,\", get2() );\n printf(\"%9.6lf,\", get3() );\n printf(\"%9.6lf)\", get4() );\n if(strlen(str2)!=0)printf(\"%s\",str2);\n}\n\n//=====================================\n// vectR4 functions\n//=====================================\n//-----------------------------------------------------------------------------\n//! \\brief return the 4-tuple value\n//-----------------------------------------------------------------------------\nconst vectR4 vectR4::get(void)\n{\n vectR4 u;\n u.put( 0, get1() );\n u.put( 1, get2() );\n u.put( 2, get3() );\n u.put( 3, get4() );\n return u;\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief magnitude\n//-----------------------------------------------------------------------------\ndouble vectR4::mag(void) const\n{\n const Eigen::Map< const Vector4d > a( getdata() );\n return a.norm();\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief Multiply the vector by a scalar a\n//-----------------------------------------------------------------------------\nvectR4 vectR4::mpy(const double a)\n{\n vectR4 w;\n const Eigen::Map< const Vector4d > vv( getdata() );\n Eigen::Map< Vector4d > ww( w.getdataa() );\n ww = a * vv;\n return w;\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief operator: +=\n//-----------------------------------------------------------------------------\nvoid vectR4::operator+=(vectR4 q)\n{\n Eigen::Map< Vector4d > pp( getdataa() );\n const Eigen::Map< const Vector4d > qq( q.getdata() );\n pp = pp + qq;\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief operator: -=\n//-----------------------------------------------------------------------------\nvoid vectR4::operator-=(vectR4 q)\n{\n Eigen::Map< Vector4d > pp( getdataa() );\n const Eigen::Map< const Vector4d > qq( q.getdata() );\n pp = pp - qq;\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief operator: -=\n//-----------------------------------------------------------------------------\nvoid vectR4::operator*=(double a)\n{\n vectR4 p=get();\n p = a*p;\n put(p);\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief operator: a*y\n//-----------------------------------------------------------------------------\nvectR4 operator*(const double a, const vectR4 x)\n{\n vectR4 y;\n const Eigen::Map< const Vector4d > xx( x.getdata() );\n Eigen::Map< Vector4d > yy( y.getdataa() );\n yy = a * xx;\n return y;\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief operator: dot product of p and q\n//-----------------------------------------------------------------------------\ndouble operator^(vectR4 p,vectR4 q)\n{\n const Eigen::Map< const Vector4d > pp( p.getdata() );\n const Eigen::Map< const Vector4d > qq( q.getdata() );\n double innerProduct = pp.adjoint() * qq;\n return innerProduct;\n}\n\n//=====================================\n//! \\brief seqR4\n//=====================================\n//-----------------------------------------------------------------------------\n//! \\brief constructor initializing seqR1 to 0\n//-----------------------------------------------------------------------------\nseqR4::seqR4(long M)\n{\n N=M;\n x = new vectR4[N];\n clear();\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief constructor initializing seqR1 to \n//-----------------------------------------------------------------------------\nseqR4::seqR4( long M, double u )\n{\n N=M;\n x = new vectR4[N];\n fill( u );\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief Fill the seqR3 with a value 0\n//-----------------------------------------------------------------------------\nvoid seqR4::clear(void)\n{\n fill( 0.0 );\n}\n\n//-----------------------------------------------------------------------------\n//! \\brief fill the seqR4 with a value \n//-----------------------------------------------------------------------------\nvoid seqR4::fill(double u)\n{\n for(long n=0; n0){\n printf(\"%s\",str1);\n if(fptr!=NULL)fprintf(fptr,\"%s\",str1);\n }\n for(n=start,m=1; n<=end; n++,m++){\n p=x[n];\n printf(\"(%5.2lf,%5.2lf,%5.2lf,%5.2lf) \",p.get1(),p.get2(),p.get3(),p.get4());\n if(m%2==0)printf(\"\\n\");\n if(fptr!=NULL){\n fprintf(fptr,\"(%5.2lf,%5.2lf,%5.2lf,%5.2lf) \",p.get1(),p.get2(),p.get3(),p.get4());\n if(m%2==0)fprintf(fptr,\"\\n\");\n }\n }\n if(strlen(str2)>0){\n printf(\"%s\",str2);\n if(fptr!=NULL)fprintf(fptr,\"%s\",str2);\n }\n }\n\n//-----------------------------------------------------------------------------\n//! \\brief list contents of seqR1 using 1 digit per element\n//-----------------------------------------------------------------------------\nvoid seqR4::list1(const long start, const long end, const char *str1, const char *str2,FILE *fptr){\n long n,m;\n vectR4 p;\n if(strlen(str1)>0){\n printf(\"%s\",str1);\n if(fptr!=NULL)fprintf(fptr,\"%s\",str1);\n }\n for(n=start,m=1; n<=end; n++,m++){\n p=x[n];\n printf(\" %1.0lf%1.0lf%1.0lf%1.0lf\",p.get1(),p.get2(),p.get3(),p.get4());\n if(fptr!=NULL)fprintf(fptr,\" %1.0lf%1.0lf%1.0lf%1.0lf\",p.get1(),p.get2(),p.get3(),p.get4());\n if(m%10==0)printf(\"\\n\");\n if(fptr!=NULL)if(m%10==0)fprintf(fptr,\"\\n\");\n }\n if(strlen(str2)>0){\n printf(\"%s\",str2);\n if(fptr!=NULL)fprintf(fptr,\"%s\",str2);\n }\n }\n\n/*=====================================\n//! \\brief external operations\n *=====================================*/\n//-----------------------------------------------------------------------------\n//! \\brief operator: return p+q\n//-----------------------------------------------------------------------------\nvectR4 operator+(vectR4 p, vectR4 q){\n int i;\n vectR4 y;\n for(i=0;i<4;i++)y.put(i,p.get(i)+q.get(i));\n return y;\n }\n\n//-----------------------------------------------------------------------------\n//! \\brief operator: return p-q\n//-----------------------------------------------------------------------------\nvectR4 operator-(vectR4 p, vectR4 q){\n int i;\n vectR4 y;\n for(i=0;i<4;i++)y.put(i,p.get(i)-q.get(i));\n return y;\n }\n\n//-----------------------------------------------------------------------------\n//! \\brief operator: return -p\n//-----------------------------------------------------------------------------\nvectR4 operator-(vectR4 p){\n vectR4 q;\n int i;\n for(i=0;i<4;i++)q.put(i,-p.get(i));\n return q;\n }\n\n//-----------------------------------------------------------------------------\n//! \\brief return the angle theta in radians between the two vectors induced by\n//! \\brief the points

and in the space R^4.\n//! \\brief on SUCCESS return theta in the closed interval [0:PI]\n//! \\brief on ERROR return negative value or exit with value EXIT_FAILURE\n//-----------------------------------------------------------------------------\ndouble pqtheta(const vectR4 p, const vectR4 q){\n const double rp = p.r();\n const double rq = q.r();\n double y,theta;\n if(rp==0) return -1;\n if(rq==0) return -2;\n y = (p^q)/(rp*rq);\n if(y>+1) {fprintf(stderr,\"\\nERROR using pqtheta(vectR4 p, vectR4 q): (p^q)/(rp*rq)=%lf>+1\\n\",y); exit(EXIT_FAILURE);}\n if(y<-1) {fprintf(stderr,\"\\nERROR using pqtheta(vectR4 p, vectR4 q): (p^q)/(rp*rq)=%lf<-1\\n\",y); exit(EXIT_FAILURE);}\n theta = acos(y);\n return theta;\n }\n\n/*=====================================\n//! \\brief external operations\n *=====================================*/\n//-----------------------------------------------------------------------------\n//! \\brief compute magnitude of R^1 sequence\n//-----------------------------------------------------------------------------\n//int mag(seqR4 *xR4, seqR1 *ymag){\n// const long Nx=xR4->getN();\n// const long Ny=ymag->getN();\n// long n;\n// int retval=0;\n// vectR4 u;\n// ymag->clear();\n// if(Nx!=Ny){\n// fprintf(stderr,\"ERROR using y=mag(xR4): lengths of xR4 (%ld) and ymag (%ld) differ.\\n\",Nx,Ny);\n// exit(EXIT_FAILURE);\n// }\n// for(n=0;nget(n);\n// ymag->put(n,u.mag());\n// }\n// return retval;\n// }\n\n", "meta": {"hexsha": "a62159806f2404112de19cc2bdf0f9788952fbca", "size": 12895, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "r4.cpp", "max_stars_repo_name": "dgreenhoe/symbolic-sequence-processing", "max_stars_repo_head_hexsha": "8e9f5a40dbddf44fd0fde0a461d7ed73208c9598", "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": "r4.cpp", "max_issues_repo_name": "dgreenhoe/symbolic-sequence-processing", "max_issues_repo_head_hexsha": "8e9f5a40dbddf44fd0fde0a461d7ed73208c9598", "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": "r4.cpp", "max_forks_repo_name": "dgreenhoe/symbolic-sequence-processing", "max_forks_repo_head_hexsha": "8e9f5a40dbddf44fd0fde0a461d7ed73208c9598", "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": 31.2227602906, "max_line_length": 120, "alphanum_fraction": 0.3499806126, "num_tokens": 2909, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7662936324115011, "lm_q2_score": 0.6513548646660543, "lm_q1q2_score": 0.4991290852338524}} {"text": "// $Id$\n//\n// Copyright (C) 2003-2009 Greg Landrum and Rational Discovery LLC\n//\n// @@ All Rights Reserved @@\n// This file is part of the RDKit.\n// The contents are covered by the terms of the BSD license\n// which is included in the file license.txt, found at the root\n// of the RDKit source tree.\n//\n#include \"MolOps.h\"\n#include \"RDKitBase.h\"\n#include \n#include \n\n#include \n#include \n\nnamespace RDKit {\nnamespace MolOps {\ndouble computeBalabanJ(double *distMat, int nb, int nAts) {\n // NOTE that the distance matrix is modified here for the sake of\n // efficiency\n PRECONDITION(distMat, \"bogus distance matrix\")\n double sum = 0.0;\n int nActive = nAts;\n int mu = nb - nActive + 1;\n\n if (mu == -1) return 0.0;\n\n for (int i = 0; i < nAts; i++) {\n int iTab = i * nAts;\n sum = 0.0;\n for (int j = 0; j < nAts; j++) {\n if (j != i) {\n sum += distMat[iTab + j];\n }\n }\n distMat[iTab + i] *= sum;\n }\n double accum = 0.0;\n for (int i = 0; i < nAts; i++) {\n int iTab = i * nAts + i;\n for (int j = i + 1; j < nAts; j++) {\n // NOTE: this isn't strictly the Balaban J value, because we\n // aren't only adding in adjacent atoms. Since we're doing a\n // discriminator, that shouldn't be a problem.\n if (j != i) {\n accum += (1.0 / sqrt(distMat[iTab] * distMat[j * nAts + j]));\n }\n }\n }\n return nActive / ((mu + 1) * accum);\n}\n\ndouble computeBalabanJ(const ROMol &mol, bool useBO, bool force,\n const std::vector *bondPath, bool cacheIt) {\n RDUNUSED_PARAM(useBO);\n double res = 0.0;\n if (!force && mol.hasProp(common_properties::BalabanJ)) {\n mol.getProp(common_properties::BalabanJ, res);\n } else {\n double *dMat;\n int nb = 0, nAts = 0;\n if (bondPath) {\n boost::dynamic_bitset<> atomsUsed(mol.getNumAtoms());\n boost::dynamic_bitset<> bondsUsed(mol.getNumBonds());\n for (int ci : *bondPath) {\n bondsUsed[ci] = 1;\n }\n std::vector bonds;\n bonds.reserve(bondPath->size());\n std::vector atomsInPath;\n atomsInPath.reserve(bondPath->size() + 1);\n\n ROMol::EDGE_ITER beg, end;\n boost::tie(beg, end) = mol.getEdges();\n while (beg != end) {\n const Bond *bond = mol[*beg];\n if (bondsUsed[bond->getIdx()]) {\n int begIdx = bond->getBeginAtomIdx();\n int endIdx = bond->getEndAtomIdx();\n bonds.push_back(bond);\n if (!atomsUsed[begIdx]) {\n atomsInPath.push_back(begIdx);\n atomsUsed[begIdx] = 1;\n }\n if (!atomsUsed[endIdx]) {\n atomsInPath.push_back(endIdx);\n atomsUsed[endIdx] = 1;\n }\n }\n beg++;\n }\n nb = rdcast(bondPath->size());\n nAts = rdcast(atomsInPath.size());\n dMat = MolOps::getDistanceMat(mol, atomsInPath, bonds, true, true);\n res = computeBalabanJ(dMat, nb, nAts);\n delete[] dMat;\n } else {\n nb = mol.getNumBonds();\n nAts = mol.getNumAtoms();\n dMat = MolOps::getDistanceMat(mol, true, true, true, nullptr);\n res = computeBalabanJ(dMat, nb, nAts);\n delete[] dMat;\n }\n\n if (cacheIt) mol.setProp(common_properties::BalabanJ, res, true);\n }\n return res;\n}\n} // end of namespace MolOps\n} // end of namespace RDKit\n", "meta": {"hexsha": "79594739693b2ad513693f030f07df38114606da", "size": 3391, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "modified_rdkit/Code/GraphMol/MolDiscriminators.cpp", "max_stars_repo_name": "hjuinj/RDKit_mETKDG", "max_stars_repo_head_hexsha": "b270e765caa61d289e9e33595d4264b156f9062e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2020-03-30T04:00:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-31T01:32:13.000Z", "max_issues_repo_path": "modified_rdkit/Code/GraphMol/MolDiscriminators.cpp", "max_issues_repo_name": "hjuinj/RDKit_mETKDG", "max_issues_repo_head_hexsha": "b270e765caa61d289e9e33595d4264b156f9062e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-05-23T17:31:04.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-26T06:52:47.000Z", "max_forks_repo_path": "modified_rdkit/Code/GraphMol/MolDiscriminators.cpp", "max_forks_repo_name": "hjuinj/RDKit_mETKDG", "max_forks_repo_head_hexsha": "b270e765caa61d289e9e33595d4264b156f9062e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2020-03-30T04:00:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-25T23:11:52.000Z", "avg_line_length": 29.7456140351, "max_line_length": 73, "alphanum_fraction": 0.5818342672, "num_tokens": 1024, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311956428946, "lm_q2_score": 0.63341027059799, "lm_q1q2_score": 0.4990837118447637}} {"text": "#include \"smooth_pair_finder.h\"\n\n#include \n\n#include \"norm_finding.h\"\n#include \"util.h\"\n\nnamespace {\n using namespace NTL;\n}\n\nnamespace gnfs {\n SmoothPairFinder::SmoothPairFinder(const ZZ& n, long B, const ZZX& f, const ZZ& m)\n : n_(n), B_(B), f_(f), m_(m), M_(B), Mold_(0), a_(B), b_(-1) {\n ZZX fprime = diff(f);\n\n // Figure out what the factorbase columns represent.\n // Each one is a pair (p,r), where p is a prime up to B\n // and r is something where f(r) \\equiv 0 (mod p).\n PrimeSeq pseq;\n long p;\n while ((p = pseq.next()) <= B) {\n cols_modular_.push_back(p);\n for (long r = 0; r < p; r++) {\n ZZ res = eval(f, ZZ(r));\n if (res % p == 0)\n cols_algebraic_.emplace_back(p, r);\n }\n }\n\n // Generate pairs (q,s) for Adleman columns.\n // For each q (named p here), find an s where\n // f(s) \\equiv 0 (mod p) and f'(s) \\not\\equiv 0 (mod p).\n long k = conv(3 * log(conv(n)));\n long k_so_far = 0;\n while (k_so_far < k) {\n for (long s = 0; s < p; s++) {\n ZZ zs(s);\n if (eval(f, zs) % p == 0 && eval(fprime, zs) % p != 0) {\n cols_adleman_.emplace_back(p, s);\n k_so_far++;\n }\n }\n\n p = pseq.next();\n }\n }\n\n bool SmoothPairFinder::add_cols_modular(long a, long b, vec_GF2& ret) {\n ZZ ammb = a - m_ * b;\n ammb %= n_;\n\n if (ammb < 0) {\n ammb *= -1;\n ret.append(GF2(1));\n } else {\n ret.append(GF2(0));\n }\n\n for (const auto& p : cols_modular_) {\n bool divcount = false;\n while (ammb % p == 0) {\n ammb /= p;\n divcount ^= true;\n }\n ret.append(divcount ? GF2(1) : GF2(0));\n }\n\n return ammb == 1;\n }\n\n bool SmoothPairFinder::add_cols_algebraic(long a, long b, vec_GF2& ret) {\n ZZ namab = eval_norm(f_, ZZ(a), ZZ(b));\n\n // Iterate through each prime.\n // For each one, find r first,\n // then set the appropriate entry in the index vector.\n\n // Here, we'll keep a cursor into cols_algebraic_.\n auto alg_it = cols_algebraic_.cbegin();\n\n for (const auto& p : cols_modular_) {\n long r = lincon(a, b, p);\n\n // Get the divcount as before\n bool divcount = false;\n while (namab % p == 0) {\n namab /= p;\n divcount ^= true;\n }\n GF2 to_add = divcount ? GF2(1) : GF2(0);\n\n // Scroll past algebraic factorbase entries\n // until we find where we want to add this item.\n // Then add it.\n while (alg_it->first != p || alg_it->second != r) {\n ++alg_it;\n ret.append(GF2(0));\n }\n ++alg_it;\n ret.append(to_add);\n }\n\n // Add the rest of the zeros to the vector that we return.\n while (alg_it != cols_algebraic_.cend()) {\n ++alg_it;\n ret.append(GF2(0));\n }\n\n return namab == 1;\n }\n\n bool SmoothPairFinder::add_cols_adleman(long a, long b, NTL::vec_GF2& ret) {\n for (const auto& qs : cols_adleman_) {\n long q = qs.first;\n long s = qs.second;\n long jacobi_top = a - b * s;\n long jacobi = Jacobi(ZZ(jacobi_top % q), ZZ(q));\n ret.append(jacobi == -1 ? GF2(1) : GF2(0));\n }\n\n return true;\n }\n\n vec_GF2 SmoothPairFinder::generate_row(long a, long b) {\n vec_GF2 ret; // if this length != num_cols, invalid\n // we always return ret so we can have the return value optimzn\n // even if ret ends up being invalid\n\n // Modular factorbase and -1.\n if (!add_cols_modular(a, b, ret)) {\n // ammb is not B-smooth\n // make SURE the length is invalid\n if (ret.length() == num_cols()) ret.append(GF2(0));\n return ret;\n }\n\n // Algebraic factorbase.\n if (!add_cols_algebraic(a, b, ret)) {\n // namab is not B-smooth\n // make SURE the length is invalid\n if (ret.length() == num_cols()) ret.append(GF2(0));\n return ret;\n }\n\n // Adleman columns.\n if (!add_cols_adleman(a, b, ret)) {\n // result is wrong\n // make SURE the length is invalid\n if (ret.length() == num_cols()) ret.append(GF2(0));\n return ret;\n }\n\n return ret;\n }\n\n std::pair, vec_GF2> SmoothPairFinder::get() {\n // TODO\n return std::make_pair(std::make_pair(0, 0), vec_GF2(INIT_SIZE, num_cols()));\n }\n}\n", "meta": {"hexsha": "ae69542a8f4c9e4064c6338e8e08a23ac8a3ea2c", "size": 4873, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/smooth_pair_finder.cc", "max_stars_repo_name": "MathSquared/general-number-field-sieve", "max_stars_repo_head_hexsha": "0ab4efd447f24b726597ec9a6ddae669b1709a20", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-05-25T09:36:07.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-23T11:54:46.000Z", "max_issues_repo_path": "src/smooth_pair_finder.cc", "max_issues_repo_name": "MathSquared/general-number-field-sieve", "max_issues_repo_head_hexsha": "0ab4efd447f24b726597ec9a6ddae669b1709a20", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-05-06T10:34:07.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-06T10:34:07.000Z", "max_forks_repo_path": "src/smooth_pair_finder.cc", "max_forks_repo_name": "MathSquared/general-number-field-sieve", "max_forks_repo_head_hexsha": "0ab4efd447f24b726597ec9a6ddae669b1709a20", "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.0802469136, "max_line_length": 86, "alphanum_fraction": 0.482864765, "num_tokens": 1321, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311956428947, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.49908370639216176}} {"text": " // graph-tool -- a general graph modification and manipulation thingy\n//\n// Copyright (C) 2006-2018 Tiago de Paula Peixoto \n//\n// This program is free software; you can redistribute it and/or\n// modify it under the terms of the GNU General Public License\n// as published by the Free Software Foundation; either version 3\n// of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU General Public License for more details.\n//\n// You should have received a copy of the GNU General Public License\n// along with this program. If not, see .\n\n#include \n#include \n\n#include \"graph_tool.hh\"\n#include \"hash_map_wrap.hh\"\n#include \"int_part.hh\"\n#include \"util.hh\"\n\ndouble spence(double);\n\nnamespace graph_tool\n{\n\nusing namespace std;\n\nboost::multi_array __q_cache;\n\ndouble log_sum(double a, double b)\n{\n return std::max(a, b) + std::log1p(exp(-abs(a-b)));\n}\n\nvoid init_q_cache(size_t n_max)\n{\n size_t old_n = __q_cache.shape()[0];\n if (old_n >= n_max)\n return;\n\n __q_cache.resize(boost::extents[n_max + 1][n_max + 1]);\n std::fill(__q_cache.data(), __q_cache.data() + __q_cache.num_elements(),\n -std::numeric_limits::infinity());\n\n for (size_t n = 1; n <= n_max; ++n)\n {\n __q_cache[n][1] = 0;\n for (size_t k = 2; k <= n; ++k)\n {\n __q_cache[n][k] = log_sum(__q_cache[n][k], __q_cache[n][k - 1]);\n if (n > k)\n __q_cache[n][k] = log_sum(__q_cache[n][k], __q_cache[n - k][k]);\n }\n }\n}\n\ndouble q_rec(int n, int k)\n{\n if (n <= 0 || k < 1)\n return 0;\n if (k > n)\n k = n;\n if (k == 1)\n return 1;\n return q_rec(n, k - 1) + q_rec(n - k, k);\n}\n\ngt_hash_map, double> __q_memo;\n\ndouble q_rec_memo(int n, int k)\n{\n if (k > n || n <= 0 || k < 1)\n return 0;\n if (k > n)\n k = n;\n if (k == 1)\n return 1;\n auto key = make_pair(n, k);\n auto iter = __q_memo.find(key);\n if (iter != __q_memo.end())\n return iter->second;\n auto res = q_rec_memo(n, k - 1) + q_rec_memo(n - k, k);\n __q_memo[key] = res;\n return res;\n}\n\ndouble log_q_approx_big(size_t n, size_t k)\n{\n double C = M_PI * sqrt(2/3.);\n double S = C * sqrt(n) - log(4 * sqrt(3) * n);\n if (k < n)\n {\n double x = k / sqrt(n) - log(n) / C;\n S -= (2 / C) * exp(-C * x / 2);\n }\n return S;\n}\n\ndouble log_q_approx_small(size_t n, size_t k)\n{\n return lbinom_fast(n - 1, k - 1) - lgamma_fast(k + 1);\n}\n\ndouble get_v(double u, double epsilon=1e-8)\n{\n double v = u;\n double delta = 1;\n while (delta > epsilon)\n {\n // spence(exp(v)) = -spence(exp(-v)) - (v*v)/2\n double n_v = u * sqrt(spence(exp(-v)));\n delta = abs(n_v - v);\n v = n_v;\n }\n return v;\n}\n\ndouble log_q_approx(size_t n, size_t k)\n{\n if (k < pow(n, 1/4.))\n return log_q_approx_small(n, k);\n double u = k / sqrt(n);\n double v = get_v(u);\n double lf = log(v) - log1p(- exp(-v) * (1 + u * u/2)) / 2 - log(2) * 3 / 2.\n - log(u) - log(M_PI);\n double g = 2 * v / u - u * log1p(-exp(-v));\n return lf - log(n) + sqrt(n) * g;\n}\n\n\n} // namespace graph_tool\n", "meta": {"hexsha": "723ed116c3e430db9f35351bc742bc6b6d7c9657", "size": 3497, "ext": "cc", "lang": "C++", "max_stars_repo_path": "graph-tool-2.27/src/graph/inference/support/int_part.cc", "max_stars_repo_name": "Znigneering/CSCI-3154", "max_stars_repo_head_hexsha": "bc318efc73d2a80025b98f5b3e4f7e4819e952e4", "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": "graph-tool-2.27/src/graph/inference/support/int_part.cc", "max_issues_repo_name": "Znigneering/CSCI-3154", "max_issues_repo_head_hexsha": "bc318efc73d2a80025b98f5b3e4f7e4819e952e4", "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": "graph-tool-2.27/src/graph/inference/support/int_part.cc", "max_forks_repo_name": "Znigneering/CSCI-3154", "max_forks_repo_head_hexsha": "bc318efc73d2a80025b98f5b3e4f7e4819e952e4", "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": 25.5255474453, "max_line_length": 80, "alphanum_fraction": 0.5784958536, "num_tokens": 1097, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461389930307512, "lm_q2_score": 0.6688802735722129, "lm_q1q2_score": 0.4990776537813043}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"mandelbrot.hpp\"\n\nusing namespace tg;\n\nconst int IMG_X = 12800;\nconst int IMG_Y ((IMG_X/(NUM_SPES*4))*3*NUM_SPES); // Approximately 4:3 aspect ratio with number of rows multiple of NUM_SPES\n\nconst int MAX_ITERATIONS = 1000;\nconst char* OUTPUT_FILE = \"mandelbrot_set.png\";\nconst float GAMMA_EXPONENT = 3.5f;\n\nconst int UNROLL_FACTOR = 8; // MUST BE A DIVISOR OF IMG_X!\nBOOST_STATIC_ASSERT(IMG_X % UNROLL_FACTOR == 0);\n\ntypedef TaskGraph mandel_tg;\n\nint main(int argc, char* argv[]) {\n int threads;\n const Options options = getOptions(\"mandelbrot\", argc, argv);\n\n if (options.threads < 1 || options.threads > NUM_SPES)\n {\n std::cerr << \"Please select a number of threads between 1 and \" << NUM_SPES << \" (inclusive).\" << std::endl;\n exit(EXIT_FAILURE);\n }\n else if (IMG_Y % options.threads != 0)\n {\n std::cerr << \"Please choose a number of threads that is a factor of the image height (\" << IMG_Y << \").\" << std::endl;\n exit(EXIT_FAILURE);\n }\n else\n {\n threads = options.threads;\n }\n\n FILE *output_file;\n boost::ptr_vector taskGraphs; \n TaskFarm tFarm;\n\n mandel_tg T; \n taskgraph(mandel_tg, T, tuple2(y_pos, line)) {\n tVar(float, x);\n tVar(float, y);\n tVar(float, x0);\n tVar(float, y0);\n tVar(float, xtemp);\n tVar(int, x_pos);\n tVar(int, iteration);\n tVar(float, pixel);\n \n y0 = (y_pos * (3.0f / IMG_Y)) - 1.5f;\n \n // Iterate over the scanline\n tFor (x_pos, 0, IMG_X - 1) {\n x0 = (x_pos * (3.5f / IMG_X)) - 2.5f;\n \n // Unroll the loop\n for (int i = 0; i < UNROLL_FACTOR; ++i) {\n x = x0;\n y = y0;\n iteration = 0;\n \n // Test if this location is in the set\n tWhile ((x*x + y*y) < 4 && iteration < MAX_ITERATIONS) {\n xtemp = (x*x) - (y*y) + x0;\n y = 2*x*y + y0;\n x = xtemp;\n iteration+=1;\n }\n\n // Calculate and set the value of the pixel\n tIf(iteration == MAX_ITERATIONS)\n pixel = 0.0f;\n tElse\n pixel = 8.0f * (iteration + 1.0f - tLogf(tLogf(tSqrtf(x*x + y*y))) / std::log(2.0f)) / MAX_ITERATIONS;\n\n line[x_pos] = tPowf(pixel, (1.0f / GAMMA_EXPONENT)) * 255.0f;\n x_pos+=1;\n }\n x_pos-=1;\n }\n }\n\n T.compile(tg::SPU_GCC, false);\n\n for(int index=0; index(NULL));\n exit(1);\n }\n \n png_init_io(png_ptr, output_file); \n png_set_IHDR(png_ptr, info_ptr, IMG_X, IMG_Y, 8,\n PNG_COLOR_TYPE_PALETTE,\n PNG_INTERLACE_NONE,\n PNG_COMPRESSION_TYPE_DEFAULT,\n PNG_FILTER_TYPE_DEFAULT);\n png_set_gamma(png_ptr, 0.5, 0.45455);\n\n std::vector palette(generateBlueYellowColourMap());\n png_set_PLTE(png_ptr, info_ptr, &palette[0], palette.size());\n png_write_info(png_ptr, info_ptr);\n \n std::vector scanlines(threads); \n\n for (int spe = 0; spe < threads; ++spe)\n scanlines[spe] = static_cast(spu_malloc(IMG_X));\n\n for (int line = 0; line < IMG_Y; line+=threads)\n {\n std::vector lineNumbers(threads);\n\n for(int spe=0; spe(scanlines[spe]);\n png_write_row(png_ptr, png_row_ptr);\n }\n }\n \n for (int spe = 0; spe < threads; ++spe)\n spu_free(scanlines[spe]);\n \n png_write_end(png_ptr, info_ptr);\n png_destroy_write_struct(&png_ptr, &info_ptr);\n\n exit(EXIT_SUCCESS);\n}\n\n", "meta": {"hexsha": "b61e607814935cc4dd5fe67de5682ceec0dcc284", "size": 4572, "ext": "cc", "lang": "C++", "max_stars_repo_path": "examples/cell/mandelbrot/mandelbrot.cc", "max_stars_repo_name": "paulhjkelly/taskgraph-metaprogramming", "max_stars_repo_head_hexsha": "54c4e2806a97bec555a90784ab4cf0880660bf89", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2020-04-11T21:30:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-04T16:16:09.000Z", "max_issues_repo_path": "examples/cell/mandelbrot/mandelbrot.cc", "max_issues_repo_name": "paulhjkelly/taskgraph-metaprogramming", "max_issues_repo_head_hexsha": "54c4e2806a97bec555a90784ab4cf0880660bf89", "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": "examples/cell/mandelbrot/mandelbrot.cc", "max_forks_repo_name": "paulhjkelly/taskgraph-metaprogramming", "max_forks_repo_head_hexsha": "54c4e2806a97bec555a90784ab4cf0880660bf89", "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": 27.5421686747, "max_line_length": 125, "alphanum_fraction": 0.6194225722, "num_tokens": 1399, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461389930307512, "lm_q2_score": 0.6688802669716106, "lm_q1q2_score": 0.49907764885633754}} {"text": "/* \n// Copyright 2018 University of Liege\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// Authors:\n// - Adrien Crovato\n*/\n\n//// Compressible module (field solver)\n// Compute field variables and field sources\n//\n// I/O:\n// - Minf: freestream Mach number\n// - vInf: freestream velocity vector\n// - bPan: (network of) body panels (structure)\n// - fPan: field panels (structure)\n// - sp: sub-panels (structure)\n// - b2fAIC: body to field AIC (structure)\n// - f2fAIC: field to field AIC (structure)\n// - spAIC: body to field AIC for subpanels (structure)\n\n#include \n#include \n#include \"solve_field.h\"\n#include \"compute_fVars.h\"\n\nusing namespace std;\nusing namespace Eigen;\n\n#define GAMMA 1.4\n#define CMU 1.0\n#define M_C 1.0\n\nvoid solve_field(double Minf, Vector3d &vInf, Network &bPan, Field &fPan, Subpanel &sp,\n Body_AIC &b2fAIC, Field2field_AIC &f2fAIC, Subpanel_AIC &spAIC) {\n\n //// Begin\n cout << \"Computing field variables... \" << flush;\n\n //// Field variables\n compute_fVars(Minf, vInf, bPan, fPan, sp, b2fAIC, f2fAIC, spAIC);\n\n //// Field sources\n // Density gradient\n for (int i = 0; i < fPan.nE; i++) {\n int f = fPan.eIdx(i);\n double dU, dV, dW; // Variables for residual\n\n // X-derivative\n double fb=0, ff=0, fb2=0, ff2=0;\n if (fPan.fbdMap(f,0)) {\n fb = (fPan.rho(f) - fPan.rho(f - 1)) / fPan.deltaX;\n fb2 = (fPan.U(f,0) - fPan.U(f - 1,0)) / fPan.deltaX;\n }\n if (fPan.fbdMap(f,1)) {\n ff = (fPan.rho(f + 1) - fPan.rho(f)) / fPan.deltaX;\n ff2 = (fPan.U(f + 1,0) - fPan.U(f,0)) / fPan.deltaX;\n }\n if (fPan.fbdMap(f,0) && fPan.fbdMap(f,1)) {\n fPan.dRho(f,0) = 0.5*(fb+ff);\n dU = 0.5*(fb2+ff2);\n }\n else {\n fPan.dRho(f,0) = fb+ff;\n dU = fb2+ff2;\n }\n\n // Y-derivative\n fb=0, ff=0, fb2=0, ff2=0;\n if (fPan.fbdMap(f,2)) {\n fb = (fPan.rho(f) - fPan.rho(f - fPan.nX*fPan.nZ)) / fPan.deltaY;\n fb2 = (fPan.U(f,1) - fPan.U(f - fPan.nX*fPan.nZ,1)) / fPan.deltaY;\n }\n if (fPan.fbdMap(f,3)) {\n ff = (fPan.rho(f + fPan.nX*fPan.nZ) - fPan.rho(f)) / fPan.deltaY;\n ff2 = (fPan.U(f + fPan.nX*fPan.nZ,1) - fPan.U(f,1)) / fPan.deltaY;\n }\n if (fPan.fbdMap(f,2) && fPan.fbdMap(f,3)) {\n fPan.dRho(f,1) = 0.5*(fb+ff);\n dV = 0.5*(fb2+ff2);\n }\n else {\n fPan.dRho(f,1) = fb+ff;\n dV = fb2+ff2;\n }\n\n // Z-derivative\n fb=0, ff=0, fb2=0, ff2=0;\n if (fPan.fbdMap(f,4)) {\n fb = (fPan.rho(f) - fPan.rho(f - fPan.nX)) / fPan.deltaZ;\n fb2 = (fPan.U(f,2) - fPan.U(f - fPan.nX,2)) / fPan.deltaZ;\n }\n if (fPan.fbdMap(f,5)) {\n ff = (fPan.rho(f + fPan.nX) - fPan.rho(f)) / fPan.deltaZ;\n ff2 = (fPan.U(f + fPan.nX,2) - fPan.U(f,2)) / fPan.deltaZ;\n }\n if (fPan.fbdMap(f,4) && fPan.fbdMap(f,5)) {\n fPan.dRho(f,2) = 0.5*(fb+ff);\n dW = 0.5*(fb2+ff2);\n }\n else {\n fPan.dRho(f,2) = fb+ff;\n dW = fb2+ff2;\n }\n\n // Field source\n fPan.sigma(f) = -1 / (fPan.rho(f)) * fPan.U.row(f).dot(fPan.dRho.row(f));\n // Residual\n fPan.epsilon(f) = dU + dV + dW - fPan.sigma(f);\n }\n\n // TODO 1) Artificial density (pros: physical; cons: does not work on MG or RG/MG)\n // TODO 2) Artificial viscosity (pros: works on RG/MG; cons: cut through surface, not physical)\n // TODO NB) With current form, x-upwinding gives same results as s-upwinding.\n\n //// Artificial viscosity\n for (int i = 0; i < fPan.nE; i++) {\n int f = fPan.eIdx(i);\n double mu, deltaSigmaX, deltaSigmaY, deltaSigmaZ; // Variables for artificial viscosity\n\n if (fPan.M(f) > M_C) {\n mu = CMU * (1 - M_C * M_C / (fPan.M(f) * fPan.M(f)));\n\n // X-contribution\n if (fPan.U(f,0) > 0 && fPan.fbdMap(f,0))\n deltaSigmaX = fPan.sigma(f) - fPan.sigma(f - 1);\n else if (fPan.U(f,0) < 0 && fPan.fbdMap(f,1))\n deltaSigmaX = fPan.sigma(f + 1) - fPan.sigma(f);\n else\n deltaSigmaX = 0;\n // Y-contribution\n if (fPan.U(f,1) > 0 && fPan.fbdMap(f,2))\n deltaSigmaY = fPan.sigma(f) - fPan.sigma(f - fPan.nX*fPan.nZ);\n else if (fPan.U(f,1) < 0 && fPan.fbdMap(f,3))\n deltaSigmaY = fPan.sigma(f + fPan.nX*fPan.nZ) - fPan.sigma(f);\n else\n deltaSigmaY = 0;\n // Z-contribution\n if (fPan.U(f,2) > 0 && fPan.fbdMap(f,4))\n deltaSigmaZ = fPan.sigma(f) - fPan.sigma(f - fPan.nX);\n else if (fPan.U(f,2) < 0 && fPan.fbdMap(f,5))\n deltaSigmaZ = fPan.sigma(f + fPan.nX) - fPan.sigma(f);\n else\n deltaSigmaZ = 0;\n\n fPan.sigma(f) -= mu / fPan.U.row(f).norm() *\n (fPan.U(f, 0) * deltaSigmaX + fPan.U(f, 1) * deltaSigmaY + fPan.U(f, 2) * deltaSigmaZ);\n }\n }\n\n cout << \"Done!\" << endl;\n cout << \"Max. Mach number: \" << fPan.M.maxCoeff() << endl;\n cout << \"Field sources strength: \" << fPan.sigma.norm() << endl << endl;\n}", "meta": {"hexsha": "90b09dd09b4f115ec1937dc6be1401f29a4b4017", "size": 5852, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/solve_field.cpp", "max_stars_repo_name": "acrovato/aero", "max_stars_repo_head_hexsha": "310e6840670f5a39ca015c61c9090f123da8cfd6", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2020-11-16T15:24:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T09:36:09.000Z", "max_issues_repo_path": "src/solve_field.cpp", "max_issues_repo_name": "acrovato/aero", "max_issues_repo_head_hexsha": "310e6840670f5a39ca015c61c9090f123da8cfd6", "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": "src/solve_field.cpp", "max_forks_repo_name": "acrovato/aero", "max_forks_repo_head_hexsha": "310e6840670f5a39ca015c61c9090f123da8cfd6", "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": 35.4666666667, "max_line_length": 118, "alphanum_fraction": 0.5251196172, "num_tokens": 1977, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833945721304, "lm_q2_score": 0.6442251201477016, "lm_q1q2_score": 0.49900608043264527}} {"text": "#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#include \r\n\r\n// Defining special types\r\ntypedef std::complex dcomp;\r\ntypedef std::vector dvec;\r\ntypedef std::vector< std::vector > ddvec;\r\ntypedef std::vector ivec;\r\ntypedef std::vector< std::vector > iivec;\r\ntypedef std::vector< std::complex > dcvec;\r\ntypedef std::vector< std::vector > > ddcvec;\r\n\r\n/* --------------------------------------------------------------------\r\n\r\n\t\tFUNCTIONS\r\n\r\n-----------------------------------------------------------------------*/\r\n\r\ninline const double pi()\r\n{\r\n\t// Set teh value fo pi\r\n\tconst double pi = std::atan(1) * 4;\r\n\treturn pi;\r\n}\r\n\r\n/* --------------------------------------------------------------------\r\n\t\tFROM MICROSECONDS TO HH:MM:SS:MS\r\n-----------------------------------------------------------------------*/\r\nstd::tuple ms_to_time(long long ms)\r\n{\r\n\t// Defining the variables\r\n\tlong long s, m, h;\r\n\r\n\t// Calculating the time in hour:minutes:seconds:microseconds\r\n\ts = ms / 1000000;\r\n\tms = ms % 1000000;\r\n\tm = s / 60;\r\n\ts = s % 60;\r\n\th = m / 60;\r\n\tm = m % 60;\r\n\r\n\treturn { ms,s,m,h };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tPRINT in HH:MM:SS:MS FORMAT\r\n-----------------------------------------------------------------------*/\r\nvoid time_print(long long ms, long long s, long long m, long long h)\r\n{\r\n\r\n\t// Print the time\r\n\tif (h < 10)\r\n\t{\r\n\t\tstd::cout << \"0\" << h << \":\";\r\n\t}\r\n\telse\r\n\t{\r\n\t\tstd::cout << \"\" << h << \":\";\r\n\t}\r\n\tif (m < 10)\r\n\t{\r\n\t\tstd::cout << \"0\" << m << \":\";\r\n\t}\r\n\telse\r\n\t{\r\n\t\tstd::cout << \"\" << m << \":\";\r\n\t}\r\n\tif (s < 10)\r\n\t{\r\n\t\tstd::cout << \"0\" << s << \":\" << ms;\r\n\t}\r\n\telse\r\n\t{\r\n\t\tstd::cout << \"\" << s << \":\" << ms;\r\n\t}\r\n\r\n\treturn;\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tCHI FROM Z\r\n-----------------------------------------------------------------------*/\r\ninline dcomp chi_from_z(dcomp z, dcomp z1, dcomp z2, double L, double mu)\r\n{\r\n\t// Defining the variables\r\n\tdcomp z0, Z, chi;\r\n\r\n\t// Calculating the chi from a z value\r\n\tz0 = 0.5 * (z1 + z2);\r\n\tZ = exp(dcomp(0, -1) * mu) * 2.0 * (z - z0) / L;\r\n\tchi = Z + sqrt(Z - 1.0) * sqrt(Z + 1.0);\r\n\r\n\treturn chi;\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tZ FROM CHI\r\n-----------------------------------------------------------------------*/\r\ninline dcomp z_from_chi(dcomp chi, dcomp z1, dcomp z2, double L, double mu)\r\n{\r\n\t// Defining the variables\r\n\tdcomp z, z0, Z;\r\n\r\n\t// Calculating the z from a chi value\r\n\tz0 = 0.5 * (z1 + z2);\r\n\tZ = 0.5 * (chi + 1.0 / chi);\r\n\tz = 0.5 * L * Z * exp(dcomp(0, 1) * mu) + z0;\r\n\r\n\treturn z;\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tANGEL CHANGE\r\n-----------------------------------------------------------------------*/\r\ninline double angel_change(dcomp z, dcomp z1, dcomp z2)\r\n{\r\n\t// Defining the variables\r\n\tdouble u, v, eta;\r\n\r\n\t// Calculating the angels\r\n\tu = arg(z - z1);\r\n\tv = arg(z1 - z2);\r\n\r\n\t// Correct to angel of 0 to 2pi\r\n\tif (u < 0)\r\n\t{\r\n\t\tu += 2 * pi();\r\n\t}\r\n\tif (v < 0)\r\n\t{\r\n\t\tv += 2 * pi();\r\n\t}\r\n\r\n\t// Calculate angel between the vectors\r\n\teta = abs(u - v);\r\n\r\n\t// Correct to angel of 0 to pi\r\n\tif (eta > pi())\r\n\t{\r\n\t\teta -= 2 * pi();\r\n\t}\r\n\r\n\teta = abs(eta);\r\n\r\n\treturn eta;\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tFIND INTERSECTION POINT\r\n-----------------------------------------------------------------------*/\r\ninline std::tuple intersection_point(dcomp z1, dcomp z2, dcomp z3, dcomp z4)\r\n{\r\n\t// Defining the variables\r\n\tdcomp zint, Z1, Z2;\r\n\tint int_check = 0;\r\n\r\n\tif (z1 != z3 || z2 != z4)\r\n\t{\r\n\t\t// Calculating the intersection point\r\n\t\tzint = ((conj(z2 - z1) * z1 - (z2 - z1) * conj(z1)) * (z4 - z3) - (conj(z4 - z3) * z3 - (z4 - z3) * conj(z3)) * (z2 - z1)) / ((z4 - z3) * conj(z2 - z1) - (z2 - z1) * conj(z4 - z3));\r\n\r\n\t\t// Check if intersection is on the lines\r\n\t\tZ1 = (zint - .5 * (z1 + z2)) / (.5 * (z1 - z2));\r\n\t\tZ2 = (zint - .5 * (z3 + z4)) / (.5 * (z3 - z4));\r\n\r\n\t\tif (real(Z1 * conj(Z1)) < 1.0)\r\n\t\t{\r\n\t\t\tif (real(Z2 * conj(Z2)) < 1.0)\r\n\t\t\t{\r\n\t\t\t\tint_check = 1;\r\n\t\t\t}\r\n\t\t}\r\n\t\t\r\n\t}\r\n\r\n\treturn { zint, int_check };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tGET DELTA\r\n-----------------------------------------------------------------------*/\r\ninline dcomp get_delta(ddcvec ab, int nab, int m, ivec pos_z1, ivec pos_z2)\r\n{\r\n\t// Defintion of variables\r\n\tdcomp delta;\r\n\r\n\tdelta = 0;\r\n\tfor (int ii = 0; ii < nab; ii++)\r\n\t{\r\n\t\t// Adding the jump for the z1 elements\r\n\t\tif (pos_z1[ii] == 1)\r\n\t\t{\r\n\t\t\tfor (int jj = 0; jj < m; jj++)\r\n\t\t\t{\r\n\t\t\t\tdelta += ab[ii][jj]* pow(-1, jj);\r\n\t\t\t}\r\n\t\t}\r\n\t\t// Adding the jump for the z2 elements\r\n\t\tif (pos_z2[ii] == 1)\r\n\t\t{\r\n\t\t\tfor (int jj = 0; jj < m; jj++)\r\n\t\t\t{\r\n\t\t\t\tdelta -= ab[ii][jj];\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t}\r\n\r\n\treturn delta;\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tTAU UNIFORM STRESS\r\n-----------------------------------------------------------------------*/\r\ninline std::tuple tau_uni(double sigma_11inf)\r\n{\r\n\t// Defining the variables\r\n\tdcomp tau_11, tau_12, phi, psi;\r\n\r\n\t// Get the phi and psi\r\n\tphi = -0.5 * sigma_11inf;\r\n\tpsi = -0.5 * sigma_11inf;\r\n\r\n\t// calculating the tau\r\n\ttau_11 = -phi - psi;\r\n\ttau_12 = -phi - phi;\r\n\r\n\treturn { tau_11, tau_12 };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tTAU CRACK\r\n-----------------------------------------------------------------------*/\r\ninline std::tuple tau_crack(dcomp z, dcomp z1, dcomp z2, double L, double mu, int m, dcvec a)\r\n{\r\n\t// Defining the variables\r\n\tdcomp chi, chi_bar, Z, chi_pow;\r\n\tdcomp dphi, dphi_bar, ddphi, dpsi;\r\n\tdcomp tau_11, tau_12, S1, L_frac;\r\n\r\n\t// Getting the chi - and Z - coordinates\r\n\tchi = chi_from_z(z, z1, z2, L, mu);\r\n\tchi_bar = conj(chi);\r\n\tZ = exp(dcomp(0, -1) * mu) * 2.0 * (z - 0.5 * (z1 + z2)) / L;\r\n\r\n\t// Calculating the series\r\n\tdphi = 0;\r\n\tdphi_bar = 0;\r\n\tddphi = 0;\r\n\tdpsi = 0;\r\n\tchi_pow = chi * chi - 1.0;\r\n\tfor (int ii = 0; ii < m; ii++)\r\n\t{\r\n\t\tdouble n = ii + 1.0;\r\n\t\tdcomp beta_n = a[ii] * n;\r\n\t\tdcomp chipow = pow(chi, (1.0 - n)) / chi_pow;\r\n\t\tdphi += conj(beta_n) * chipow;\r\n\t\tdphi_bar += beta_n * conj(chipow);\r\n\t\tddphi -= conj(beta_n) * (pow(chi, (2.0 - n)) / (chi_pow * chi_pow * chi_pow)) * ((n + 1.0) * chi * chi - n + 1.0);\r\n\t\tdpsi -= beta_n * chipow;\r\n\t}\r\n\r\n\t// Multiplying the constants\r\n\tL_frac = (4.0 / L) * exp(dcomp(0, -1) * mu);\r\n\tdphi *= L_frac;\r\n\tdphi_bar *= conj(L_frac);\r\n\tddphi *= (16.0 / (L * L)) * exp(dcomp(0, -2) * mu);\r\n\tdpsi *= L_frac;\r\n\r\n\t// Calcualting tau\r\n\ttau_11 = -0.5 * L * (Z - conj(Z)) * ddphi - exp(dcomp(0, -1) * mu) * (dphi + dpsi);\r\n\ttau_12 = -exp(dcomp(0, 1) * mu) * dphi - exp(dcomp(0, -1) * mu) * dphi_bar;\r\n\r\n\treturn { tau_11, tau_12 };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tTAU TOTAL\r\n-----------------------------------------------------------------------*/\r\ninline std::tuple tau_total(dcomp z, double sigma_11inf, dcvec z1, dcvec z2, dvec L, dvec mu, int ma, int na, ddcvec a, int m_not_a)\r\n{\r\n\t// Defining the variables\r\n\tdcomp tau_11, tau_12;\r\n\r\n\t// Add the unifrom stress field\r\n\tstd::tie(tau_11, tau_12) = tau_uni(sigma_11inf);\r\n\r\n\t// Add the analytic element for a crack\r\n\tif (na > 0)\r\n\t{\r\n\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t{\r\n\t\t\tif (ii != m_not_a)\r\n\t\t\t{\r\n\t\t\t\tdcomp tau_11c, tau_12c;\r\n\t\t\t\tstd::tie(tau_11c, tau_12c) = tau_crack(z, z1[ii], z2[ii], L[ii], mu[ii], ma, a[ii]);\r\n\t\t\t\ttau_11 += tau_11c;\r\n\t\t\t\ttau_12 += tau_12c;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\treturn { tau_11, tau_12 };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tT TOTAL\r\n-----------------------------------------------------------------------*/\r\ninline dcomp T_total(dcomp z, double sigma_11inf, dcvec z1a, dcvec z2a, dvec La, dvec mua, int ma, int na, ddcvec a, int m_not_a, int m_is_a)\r\n{\r\n\t// Defining the variables\r\n\tdcomp tau_11, tau_12, T;\r\n\r\n\t// Get teh taus\r\n\tstd::tie(tau_11, tau_12) = tau_total(z, sigma_11inf, z1a, z2a, La, mua, ma, na, a, m_not_a);\r\n\r\n\t// Calculate the tractions\r\n\tT = dcomp(0, -.5) * (tau_11 * exp(dcomp(0, 2) * mua[m_is_a]) - tau_12);\r\n\r\n\treturn { T };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tSOLVE CRACK ANALYTIC ELEMENT A (BETA IN PAPER)\r\n-----------------------------------------------------------------------*/\r\ninline dcvec AE_crack_solver(Eigen::VectorXd T_s, Eigen::VectorXd T_n, Eigen::MatrixXd A, int ma, int Na, dvec pa, double sigma_11inf, dcvec z1a, dcvec z2a, dvec La, dvec mua, int na, ddcvec a_in, dcvec zint, ivec int_check, int m_is_a)\r\n{\r\n\t// Defining the variables\r\n\tdcvec a(ma);\r\n\tEigen::VectorXd b1(ma);\r\n\tEigen::VectorXd b2(ma);\r\n\r\n\t// Count number of intersections\r\n\tint int_count = std::accumulate(int_check.begin(), int_check.end(), 0.0);\r\n\r\n\t// Check if the crack has any intersection\r\n\tif (int_count == 0)\r\n\t{\r\n\t\t// Solving the linear system (without intersections)\r\n\t\tb1 = A.bdcSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(T_s);\r\n\t\tb2 = A.bdcSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(T_n);\r\n\t}\r\n\telse\r\n\t{\r\n\t\t// Define new matrices for A and T and assign the pre-calculated values\r\n\t\tEigen::MatrixXd A_int_s(Na + int_count * 3, ma);\r\n\t\tEigen::MatrixXd A_int_n(Na + int_count, ma);\r\n\t\tEigen::VectorXd T_s_int(Na + int_count * 3);\r\n\t\tEigen::VectorXd T_n_int(Na + int_count);\r\n\t\t#pragma omp parallel for default(none) shared(A_int_s, A_int_n, A, T_n_int, T_n, T_s_int, T_s)\r\n\t\tfor (int ii = 0; ii < Na; ii++)\r\n\t\t{\r\n\t\t\tfor (int jj = 0; jj < ma; jj++)\r\n\t\t\t{\r\n\t\t\t\t/*A_int_re(ii, jj) = A(ii, jj);\r\n\t\t\t\tA_int_im(ii, jj) = A(ii, jj);*/\r\n\t\t\t\tA_int_s(ii, jj) = A(ii, jj);\r\n\t\t\t\tA_int_n(ii, jj) = A(ii, jj);\r\n\t\t\t}\r\n\t\t\tT_s_int(ii) = T_s(ii);\r\n\t\t\tT_n_int(ii) = T_n(ii);\r\n\t\t}\r\n\t\tint cnt_s = 0;\r\n\t\tint cnt_n = 0;\r\n\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t{\r\n\t\t\t// Check if element ii has any intersections\r\n\t\t\tif (int_check[ii] == 1)\r\n\t\t\t{\r\n\t\t\t\t// Define variables\r\n\t\t\t\tdcomp chia, tau11, chi_pow, L_frac, T_temp;\r\n\t\t\t\tdouble thetaa;\r\n\r\n\t\t\t\t// Compute the intersection angel in the chi-plane\r\n\t\t\t\tchia = chi_from_z(zint[ii], z1a[m_is_a], z2a[m_is_a], La[m_is_a], mua[m_is_a]);\r\n\t\t\t\tthetaa = imag(log(chia));\r\n\r\n\t\t\t\t// Pre-calcualte terms\r\n\t\t\t\tchi_pow = chia /( chia * chia - 1.0 );\r\n\t\t\t\tL_frac = (dcomp(0,8.0) / La[m_is_a]) * exp(dcomp(0, -2) * mua[m_is_a]);\r\n\r\n\t\t\t\t// Add the intersection to the A matrix\r\n\t\t\t\tfor (int jj = 0; jj < ma; jj++)\r\n\t\t\t\t{\r\n\t\t\t\t\tdouble n = jj + 1.0;\r\n\t\t\t\t\t// Add a control point at the intersection - tau^11 condition\r\n\t\t\t\t\tA_int_s(Na + cnt_s, jj) = real( chi_pow * L_frac * n * pow(chia, -n) );\r\n\t\t\t\t\tA_int_s(Na + (cnt_s + 1), jj) = imag( chi_pow * L_frac * n * pow(chia, -n) );\r\n\t\t\t\t\t\r\n\t\t\t\t\t// Add a control point at the intersection - traction condition\r\n\t\t\t\t\tA_int_s(Na + (cnt_s + 2), jj) = n * sin(n * thetaa);\r\n\t\t\t\t\tA_int_n(Na + cnt_n, jj) = n * sin(n * thetaa);\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Calculate the taus at the intersection\r\n\t\t\t\tdcomp tau_11, tau_12;\r\n\t\t\t\tstd::tie(tau_11, tau_12) = tau_total(zint[ii], sigma_11inf, z1a, z2a, La, mua, ma, na, a_in, m_is_a);\r\n\r\n\t\t\t\t// Add the intersection to the T_s vector\r\n\t\t\t\tT_s_int(Na + cnt_s) = -real(tau_11);\r\n\t\t\t\tT_s_int(Na + (cnt_s + 1)) = -imag(tau_11);\r\n\r\n\t\t\t\t// Calculate the traction at the control point at the intersection\r\n\t\t\t\tT_temp = T_total(zint[ii], sigma_11inf, z1a, z2a, La, mua, ma, na, a_in, m_is_a, m_is_a);\r\n\r\n\t\t\t\t// Add the intersection to the T vectors\r\n\t\t\t\tT_s_int(Na + (cnt_s + 2)) = real(T_temp) * 0.5 * La[m_is_a] * sin(thetaa);\r\n\t\t\t\tT_n_int(Na + cnt_n) = (pa[ii] + imag(T_temp)) * -0.5 * La[m_is_a] * sin(thetaa);\r\n\r\n\t\t\t\t// Add step to loop count\r\n\t\t\t\tcnt_s += 3;\r\n\t\t\t\tcnt_n += 1;\r\n\t\t\t}\r\n\t\t\t\r\n\t\t}\r\n\r\n\t\t// Solving the linear system (with intersections)\r\n\t\tb1 = A_int_s.bdcSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(T_s_int);\r\n\t\tb2 = A_int_n.bdcSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(T_n_int);\r\n\t}\r\n\t// Assign to a\r\n\tfor (int ii = 0; ii < ma; ii++)\r\n\t{\r\n\t\ta[ii] = dcomp(b2[ii], b1[ii]);\r\n\t}\r\n\r\n\r\n\treturn { a };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tITERATOR\r\n-----------------------------------------------------------------------*/\r\ninline ddcvec iterator(double cond, int ITR, int Na, dvec pa, double sigma_11inf, dcvec z1a, dcvec z2a, dvec La, dvec mua, int ma, int na)\r\n{\r\n\t// Defining the variables\r\n\tdcomp tau_11, tau_12, T;\r\n\tEigen::MatrixXd A(Na, ma);\r\n\tdvec theta_a(Na);\r\n\tddvec term(na, dvec(Na));\r\n\tddcvec za(na, dcvec(Na));\r\n\tddcvec a(na, dcvec(ma));\r\n\tddcvec zint(na, dcvec(na));\r\n\tiivec int_check(na, ivec(na));\r\n\tivec int_count(na);\r\n\tdouble theta_0a, delthetaa;\r\n\r\n\t// Print the conditions\r\n\tstd::cout << std::scientific;\r\n\tstd::cout << \"Solver for \" << na << \" analytical element cracks with \" << ma << \" coefficients at \" << Na << \" integration points.\" << std::endl;\r\n\tstd::cout << \"Iterations break after: error < \" << cond << \" or iterations > \" << ITR << \".\" << std::endl << std::endl;\r\n\tstd::cout << \"\tError:\" << \"\t\tIteration:\" << std::endl;\r\n\r\n\r\n\t// Assigning variables\r\n\ttheta_0a = pi() / (Na);\r\n\tdelthetaa = (pi() - 2.5*theta_0a) / (Na - 1.0);\r\n\r\n\tif (na > 0)\r\n\t{\r\n\t\t// Find the intersection points\r\n\t\t#pragma omp parallel for default(none) shared(zint, int_check, int_count, z1a, z2a)\r\n\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t{\r\n\t\t\tfor (int jj = 0; jj < na; jj++)\r\n\t\t\t{\r\n\t\t\t\tstd::tie(zint[ii][jj], int_check[ii][jj]) = intersection_point(z1a[ii], z2a[ii], z1a[jj], z2a[jj]);\r\n\t\t\t}\r\n\t\t\tint_count[ii] = std::accumulate(int_check[ii].begin(), int_check[ii].end(), 0.0);\r\n\t\t}\r\n\r\n\t\t// Calculating the A, a theta and term matrices\r\n\t\t#pragma omp parallel for default(none) shared(theta_a, theta_0a, delthetaa)\r\n\t\tfor (int ii = 0; ii < Na; ii++)\r\n\t\t{\r\n\t\t\ttheta_a[ii] = theta_0a + ii * delthetaa;\r\n\t\t}\r\n\r\n\t\t//#pragma omp parallel for default(none) shared(A, za, term, z1a, z2a, La, mua, theta_a)\r\n\t\tfor (int ii = 0; ii < Na; ii++)\r\n\t\t{\r\n\t\t\tfor (int mm = 0; mm < ma; mm++)\r\n\t\t\t{\r\n\t\t\t\tA(ii, mm) = (mm + 1.0) * sin((mm + 1.0) * theta_a[ii]);\r\n\t\t\t}\r\n\t\t\tfor (int jj = 0; jj < na; jj++)\r\n\t\t\t{\r\n\t\t\t\tdcomp chi;\r\n\t\t\t\tchi = exp(dcomp(0, 1) * theta_a[ii]);\r\n\t\t\t\tza[jj][ii] = z_from_chi(chi, z1a[jj], z2a[jj], La[jj], mua[jj]);\r\n\t\t\t\tterm[jj][ii] = -0.5 * La[jj] * sin(theta_a[ii]);\r\n\t\t\t}\r\n\t\t}\r\n\t\t\r\n\t}\r\n\r\n\t// Sovle the a (betas in paper)\r\n\tdouble error = 1;\r\n\tddcvec a_old(na, dcvec(ma, 0));\r\n\tdouble error_a;\r\n\tint NIT = 0;\r\n\twhile ( error > cond && NIT < ITR )\r\n\t{\r\n\t\t\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t\t\t{\r\n\t\t\t\t\tEigen::VectorXd T_s(Na);\r\n\t\t\t\t\tEigen::VectorXd T_n(Na);\r\n\t\t\t\t\t#pragma omp parallel for default(none) shared(T_s, T_n, za, sigma_11inf, z1a, z2a, La, mua, ma, na, a)\r\n\t\t\t\t\tfor (int jj = 0; jj < Na; jj++)\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdcomp T;\r\n\t\t\t\t\t\tT = T_total(za[ii][jj], sigma_11inf, z1a, z2a, La, mua, ma, na, a, ii, ii);\r\n\t\t\t\t\t\tT_s(jj) = -real(T) * term[ii][jj];\r\n\t\t\t\t\t\tT_n(jj) = (pa[ii] + imag(T)) * term[ii][jj];\r\n\t\t\t\t\t}\r\n\t\t\t\t\tdcomp tau_11, tau_12;\r\n\t\t\t\t\ta[ii] = AE_crack_solver(T_s, T_n, A, ma, Na, pa, sigma_11inf, z1a, z2a, La, mua, na, a, zint[ii], int_check[ii], ii);\r\n\t\t\t\t\tstd::tie(tau_11, tau_12) = tau_total(zint[0][1], sigma_11inf, z1a, z2a, La, mua, ma, na, a, -1);\r\n\t\t\t\t}\r\n\r\n\t\t// Calcualte the error\r\n\t\terror_a = 0;\r\n\t\tif (na > 0)\r\n\t\t{\r\n\t\t\tdvec dela(na);\r\n\t\t\t#pragma omp parallel for default(none) shared(dela, a, error_a)\r\n\t\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t\t{\r\n\t\t\t\tdvec dela_temp(ma);\r\n\t\t\t\tfor (int jj = 0; jj < ma; jj++)\r\n\t\t\t\t{\r\n\t\t\t\t\tdela_temp[jj] = abs(a[ii][jj] - a_old[ii][jj]);\r\n\t\t\t\t}\r\n\t\t\t\tdela[ii] = *max_element(dela_temp.begin(), dela_temp.end());\r\n\t\t\t}\r\n\t\t\terror_a = *max_element(dela.begin(), dela.end());\r\n\t\t}\r\n\t\tdvec error_vec{ error_a };\r\n\t\terror = *max_element(error_vec.begin(), error_vec.end());\r\n\r\n\t\tNIT += 1;\r\n\t\ta_old = a;\r\n\r\n\t\tstd::cout << std::scientific;\r\n\t\tstd::cout << \"\t\" << error << \"\t\" << NIT << std::endl;\r\n\r\n\t}\r\n\r\n\treturn { a };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tSTRESS TOTAL\r\n-----------------------------------------------------------------------*/\r\ninline std::tuple sigma_total(dcomp z, double sigma_11inf, dcvec z1a, dcvec z2a, dvec La, dvec mua, int ma, int na, ddcvec a)\r\n{\r\n\t// Defining the variables\r\n\tdcomp S1, S2, tau_11, tau_12;\r\n\tdouble sigma_11, sigma_22, sigma_12;\r\n\r\n\t// Calculating the tau\r\n\tstd::tie(tau_11, tau_12) = tau_total(z, sigma_11inf, z1a, z2a, La, mua, ma, na, a, -1);\r\n\r\n\t// Calculate the sigmas\r\n\tS1 = .5 * (tau_11 + tau_12);\r\n\tS2 = .5 * (-tau_11 + tau_12);\r\n\tsigma_11 = real(S1);\r\n\tsigma_22 = real(S2);\r\n\tsigma_12 = -imag(S1);\r\n\r\n\treturn { sigma_11, sigma_22, sigma_12 };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tSTRESS FIELD\r\n-----------------------------------------------------------------------*/\r\nstd::tuple stress_field(double xfrom, double xto, double yfrom, double yto, int Nx, int Ny, double sigma_11inf, dcvec z1a, dcvec z2a, dvec La, dvec mua, int ma, int na, ddcvec a)\r\n{\r\n\t// Defining the variables\r\n\tddvec grid_11(Nx, dvec(Ny));\r\n\tddvec grid_22(Nx, dvec(Ny));\r\n\tddvec grid_12(Nx, dvec(Ny));\r\n\tdouble dx;\r\n\tdouble dy;\r\n\tdvec x_vec(Nx);\r\n\tdvec y_vec(Ny);\r\n\r\n\t// Calcualte the sigma grids\r\n\tdx = (xto - xfrom) / (Nx - 1.0);\r\n\tdy = (yto - yfrom) / (Ny - 1.0);\r\n\t#pragma omp parallel for default(none) shared(grid_11, grid_22, grid_12, x_vec, y_vec, sigma_11inf, z1a, z2a, La, mua, ma, na, a)\r\n\tfor (int ii = 0; ii < Nx; ii++)\r\n\t{\r\n\t\tfor (int jj = Ny; jj--;)\r\n\t\t{\r\n\t\t\tx_vec[ii] = xfrom + ii * dx;\r\n\t\t\ty_vec[jj] = yfrom + jj * dy;\r\n\t\t\tstd::tie(grid_11[ii][jj], grid_22[ii][jj], grid_12[ii][jj]) = sigma_total(dcomp(x_vec[ii], y_vec[jj]), sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t}\r\n\t}\r\n\treturn { x_vec, y_vec, grid_11, grid_22, grid_12 };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tPRINCIPAL STRESSES\r\n-----------------------------------------------------------------------*/\r\nstd::tuple principal_sigma(dcomp z, double sigma_11inf, dcvec z1a, dcvec z2a, dvec La, dvec mua, int ma, int na, ddcvec a)\r\n{\r\n\t// Defining the variables\r\n\tdouble sigma_1;\r\n\tdouble sigma_2;\r\n\tdouble theta_p;\r\n\tdouble frac1, frac2, sqrt1;\r\n\tdcomp S1, S2, tau_11, tau_12;\r\n\tdouble sigma_11, sigma_22, sigma_12;\r\n\r\n\t// Calculating the tau\r\n\tstd::tie(tau_11, tau_12) = tau_total(z, sigma_11inf, z1a, z2a, La, mua, ma, na, a, -1);\r\n\r\n\t// Calculate the sigmas\r\n\tS1 = .5 * (tau_11 + tau_12);\r\n\tS2 = .5 * (-tau_11 + tau_12);\r\n\tsigma_11 = real(S1);\r\n\tsigma_22 = real(S2);\r\n\tsigma_12 = -imag(S1);\r\n\r\n\t// Calculating the terms\r\n\tfrac1 = (sigma_11 + sigma_22) / 2.0;\r\n\tfrac2 = (sigma_11 - sigma_22) / 2.0;\r\n\tsqrt1 = sqrt(frac2 * frac2 + sigma_12 * sigma_12);\r\n\r\n\t// Calculating the principal stresses and the angel of sigma\r\n\tsigma_1 = frac1 + sqrt1;\r\n\tsigma_2 = frac1 - sqrt1;\r\n\r\n\t// Calcuating the angel theta_p\r\n\ttheta_p = -0.5 * imag(log(tau_11));\r\n\r\n\t// Changing the absolut sigma is sigma_2 > sigma_1 (TURNED OFF)\r\n\t/*if (abs(sigma_2) > abs(sigma_1))\r\n\t{\r\n\t\tsigma_1 = frac1 - sqrt1;\r\n\t\tsigma_2 = frac1 + sqrt1;\r\n\t\ttheta_p = -0.5*imag(log(tau_11)) + pi() / 2;\r\n\t}\r\n\t*/\r\n\r\n\r\n\r\n\treturn { sigma_1, sigma_2, theta_p };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tPRINCIPAL STRESSES PLOT\r\n-----------------------------------------------------------------------*/\r\nstd::tuple principal_sigma_plt(double sigma_11, double sigma_22, double sigma_12)\r\n{\r\n\t// Defining the variables\r\n\tdouble sigma_1;\r\n\tdouble sigma_2;\r\n\tdouble theta_p;\r\n\tdouble frac1, frac2, sqrt1;\r\n\tdcomp tau_11;\r\n\r\n\t// Calculating the tau\r\n\ttau_11 = sigma_11 - sigma_22 - dcomp(0, 2) * sigma_12;\r\n\r\n\t// Calculating the terms\r\n\tfrac1 = (sigma_11 + sigma_22) / 2.0;\r\n\tfrac2 = (sigma_11 - sigma_22) / 2.0;\r\n\tsqrt1 = sqrt(frac2 * frac2 + sigma_12 * sigma_12);\r\n\r\n\t// Calculating the principal stresses and the angel of sigma\r\n\tsigma_1 = frac1 + sqrt1;\r\n\tsigma_2 = frac1 - sqrt1;\r\n\r\n\t// Calcuating the angel theta_p\r\n\ttheta_p = -0.5 * imag(log(tau_11));\r\n\r\n\t// Changing the absolut sigma is sigma_2 > sigma_1 (TURNED OFF)\r\n\t/*if (abs(sigma_2) > abs(sigma_1))\r\n\t{\r\n\t\tsigma_1 = frac1 - sqrt1;\r\n\t\tsigma_2 = frac1 + sqrt1;\r\n\t\ttheta_p = -0.5*imag(log(tau_11)) + pi() / 2;\r\n\t}\r\n\t*/\r\n\r\n\r\n\r\n\treturn { sigma_1, sigma_2, theta_p };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tPRINCIPAL STRESS FIELDS\r\n-----------------------------------------------------------------------*/\r\nstd::tuple principal_stress_field(int Nx, int Ny, ddvec grid_11, ddvec grid_22, ddvec grid_12)\r\n{\r\n\t// Defining the variables\r\n\tddvec grid_1(Nx, dvec(Ny));\r\n\tddvec grid_2(Nx, dvec(Ny));\r\n\tddvec grid_tp(Nx, dvec(Ny));\r\n\r\n\t// Calculate teh principal stresses from the stress feilds\r\n\t#pragma omp parallel for default(none) shared(grid_1, grid_2, grid_tp, grid_11, grid_22, grid_12)\r\n\tfor (int ii = 0; ii < Nx; ii++)\r\n\t{\r\n\t\tfor (int jj = Ny; jj--;)\r\n\t\t{\r\n\t\t\tstd::tie(grid_1[ii][jj], grid_2[ii][jj], grid_tp[ii][jj]) = principal_sigma_plt(grid_11[ii][jj], grid_22[ii][jj], grid_12[ii][jj]);\r\n\t\t}\r\n\t}\r\n\treturn { grid_1, grid_2, grid_tp };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tPRINCIPAL STRESS TRAJECTORIES\r\n-----------------------------------------------------------------------*/\r\nstd::tuple principal_stress_trajectories(double xfrom, double xto, double yfrom, double yto, dcvec xtraj, dcvec ytraj, int Ntraj, int lvs_traj, double sigma_11inf, dcvec z1a, dcvec z2a, dvec La, dvec mua, int ma, int na, ddcvec a)\r\n{\r\n\t// Defining the variables\r\n\tddcvec traj_1(lvs_traj * 2, dcvec(Ntraj));\r\n\tddcvec traj_2(lvs_traj * 2, dcvec(Ntraj));\r\n\tdouble dx, dy, dx_lvsre, dx_lvsim, dy_lvsre, dy_lvsim, pi_val;\r\n\tdouble cond;\r\n\tint NIT;\r\n\r\n\t// Getting the starting points\r\n\tdx = (xto - xfrom) / (Ntraj * 0.8);\r\n\tdy = (yto - yfrom) / (Ntraj * 0.8);\r\n\tdx_lvsre = (real(xtraj[1]) - real(xtraj[0])) / (lvs_traj - 1.0);\r\n\tdx_lvsim = (imag(xtraj[1]) - imag(xtraj[0])) / (lvs_traj - 1.0);\r\n\tdy_lvsre = (real(ytraj[1]) - real(ytraj[0])) / (lvs_traj - 1.0);\r\n\tdy_lvsim = (imag(ytraj[1]) - imag(ytraj[0])) / (lvs_traj - 1.0);\r\n\tpi_val = 0.5 * pi();\r\n\tcond = 1e-6;\r\n\tNIT = 10;\r\n\r\n\t// SIGMA 1\r\n\t#pragma omp parallel for default(none) shared(traj_1, sigma_11inf, z1a, z2a, La, mua, ma, na, a)\r\n\tfor (int ii = 0; ii < lvs_traj; ii++)\r\n\t{\r\n\t\ttraj_1[ii][0] = dcomp(real(xtraj[0]) + ii * dx_lvsre, imag(xtraj[0]) + ii * dx_lvsim);\r\n\t\tdcomp z = traj_1[ii][0];\r\n\t\tdcomp z_old = z;\r\n\t\tdouble dx1 = dx;\r\n\t\tfor (int jj = 1; jj < Ntraj; jj++)\r\n\t\t{\r\n\t\t\tdcomp zt, z11, z_oldt, sigma, sigmat;\r\n\t\t\tdouble sigma_1, theta_p;\r\n\t\t\tdouble ee, eta;\r\n\t\t\tstd::tie(sigma_1, std::ignore, theta_p) = principal_sigma(z, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t\tsigma = abs(sigma_1) * exp(dcomp(0, 1) * theta_p);\r\n\t\t\tz11 = z + sigma / abs(sigma) * dx1;\r\n\t\t\teta = angel_change(z11, z, z_old);\r\n\t\t\tif (eta > pi_val && jj > 1) {\r\n\t\t\t\tdx1 = -dx1;\r\n\t\t\t}\r\n\t\t\tzt = z + sigma / abs(sigma) * dx1;\r\n\r\n\t\t\tee = 1;\r\n\t\t\tfor (int rr = NIT; rr--;)\r\n\t\t\t{\r\n\t\t\t\tz_oldt = zt;\r\n\t\t\t\tstd::tie(sigma_1, std::ignore, theta_p) = principal_sigma(zt, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t\t\tsigmat = abs(sigma_1) * exp(dcomp(0, 1) * theta_p);\r\n\t\t\t\tz11 = z + (sigma + sigmat) / abs(sigma + sigmat) * dx1;\r\n\t\t\t\teta = angel_change(z11, z, z_old);\r\n\t\t\t\tif (eta > pi_val && jj > 1) {\r\n\t\t\t\t\tdx1 = -dx1;\r\n\t\t\t\t}\r\n\t\t\t\tzt = z + (sigma + sigmat) / abs(sigma + sigmat) * dx1;\r\n\t\t\t\tee = std::norm(z_oldt - zt);\r\n\t\t\t\tif (ee < cond)\r\n\t\t\t\t{\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\ttraj_1[ii][jj] = zt;\r\n\t\t\tz_old = z;\r\n\t\t\tz = zt;\r\n\t\t}\r\n\r\n\t\tint kk = ii + lvs_traj;\r\n\t\ttraj_1[kk][0] = traj_1[ii][0];\r\n\t\tz = traj_1[kk][0];\r\n\t\tz_old = z;\r\n\t\tdx1 = -dx;\r\n\t\tfor (int jj = 1; jj < Ntraj; jj++)\r\n\t\t{\r\n\t\t\tdcomp zt, z11, z_oldt, sigma, sigmat;\r\n\t\t\tdouble sigma_1, theta_p;\r\n\t\t\tdouble ee, eta;\r\n\t\t\tstd::tie(sigma_1, std::ignore, theta_p) = principal_sigma(z, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t\tsigma = abs(sigma_1) * exp(dcomp(0, 1) * theta_p);\r\n\t\t\tz11 = z + sigma / abs(sigma) * dx1;\r\n\t\t\teta = angel_change(z11, z, z_old);\r\n\t\t\tif (eta > pi_val && jj > 1) {\r\n\t\t\t\tdx1 = -dx1;\r\n\t\t\t}\r\n\t\t\tzt = z + sigma / abs(sigma) * dx1;\r\n\r\n\t\t\tee = 1;\r\n\t\t\tfor (int rr = NIT; rr--;)\r\n\t\t\t{\r\n\t\t\t\tz_oldt = zt;\r\n\t\t\t\tstd::tie(sigma_1, std::ignore, theta_p) = principal_sigma(zt, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t\t\tsigmat = abs(sigma_1) * exp(dcomp(0, 1) * theta_p);\r\n\t\t\t\tz11 = z + (sigma + sigmat) / abs(sigma + sigmat) * dx1;\r\n\t\t\t\teta = angel_change(z11, z, z_old);\r\n\t\t\t\tif (eta > pi_val && jj > 1) {\r\n\t\t\t\t\tdx1 = -dx1;\r\n\t\t\t\t}\r\n\t\t\t\tzt = z + (sigma + sigmat) / abs(sigma + sigmat) * dx1;\r\n\t\t\t\tee = std::norm(z_oldt - zt);\r\n\t\t\t\tif (ee < cond)\r\n\t\t\t\t{\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\ttraj_1[kk][jj] = zt;\r\n\t\t\tz_old = z;\r\n\t\t\tz = zt;\r\n\t\t}\r\n\t}\r\n\r\n\t// SIGMA 2\r\n\t#pragma omp parallel for default(none) shared(traj_2, sigma_11inf, z1a, z2a, La, mua, ma, na, a)\r\n\tfor (int ii = 0; ii < lvs_traj; ii++)\r\n\t{\r\n\t\ttraj_2[ii][0] = dcomp(real(ytraj[0]) + ii * dy_lvsre, imag(ytraj[0]) + ii * dy_lvsim);\r\n\t\tdouble dy1 = dy;\r\n\t\tdcomp z = traj_2[ii][0];\r\n\t\tdcomp z_old = z;\r\n\t\tfor (int jj = 1; jj < Ntraj; jj++)\r\n\t\t{\r\n\t\t\tdcomp zt, z11, z_oldt, sigma, sigmat;\r\n\t\t\tdouble sigma_2, theta_p;\r\n\t\t\tdouble ee, eta;\r\n\t\t\tstd::tie(std::ignore, sigma_2, theta_p) = principal_sigma(z, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t\tsigma = abs(sigma_2) * exp(dcomp(0, 1) * (theta_p + pi_val));\r\n\t\t\tz11 = z + sigma / abs(sigma) * dy1;\r\n\t\t\teta = angel_change(z11, z, z_old);\r\n\t\t\tif (eta > pi_val && jj > 1) {\r\n\t\t\t\tdy1 = -dy1;\r\n\t\t\t}\r\n\t\t\tzt = z + sigma / abs(sigma) * dy1;\r\n\r\n\t\t\tee = 1;\r\n\t\t\tfor (int rr = NIT; rr--;)\r\n\t\t\t{\r\n\t\t\t\tz_oldt = zt;\r\n\t\t\t\tstd::tie(std::ignore, sigma_2, theta_p) = principal_sigma(zt, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t\t\tsigmat = abs(sigma_2) * exp(dcomp(0, 1) * (theta_p + pi_val));\r\n\t\t\t\tz11 = z + (sigma + sigmat) / abs(sigma + sigmat) * dy1;\r\n\t\t\t\teta = angel_change(z11, z, z_old);\r\n\t\t\t\tif (eta > pi_val && jj > 1) {\r\n\t\t\t\t\tdy1 = -dy1;\r\n\t\t\t\t}\r\n\t\t\t\tzt = z + (sigma + sigmat) / abs(sigma + sigmat) * dy1;\r\n\t\t\t\tee = std::norm(z_oldt - zt);\r\n\t\t\t\tif (ee < cond)\r\n\t\t\t\t{\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\ttraj_2[ii][jj] = zt;\r\n\t\t\tz_old = traj_2[ii][(int)(jj - 1)];\r\n\t\t\tz = zt;\r\n\t\t}\r\n\r\n\t\tint kk = ii + lvs_traj;\r\n\t\ttraj_2[kk][0] = traj_2[ii][0];\r\n\t\tdy1 = -dy;\r\n\t\tz = traj_2[kk][0];\r\n\t\tz_old = z;\r\n\t\tfor (int jj = 1; jj < Ntraj; jj++)\r\n\t\t{\r\n\t\t\tdcomp zt, z11, z_oldt, sigma, sigmat;\r\n\t\t\tdouble sigma_2, theta_p;\r\n\t\t\tdouble ee, eta;\r\n\t\t\tstd::tie(std::ignore, sigma_2, theta_p) = principal_sigma(z, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t\tsigma = abs(sigma_2) * exp(dcomp(0, 1) * (theta_p + pi_val));\r\n\t\t\tz11 = z + sigma / abs(sigma) * dy1;\r\n\t\t\teta = angel_change(z11, z, z_old);\r\n\t\t\tif (eta > pi_val && jj > 1) {\r\n\t\t\t\tdy1 = -dy1;\r\n\t\t\t}\r\n\t\t\tzt = z + sigma / abs(sigma) * dy1;\r\n\r\n\t\t\tee = 1;\r\n\t\t\tfor (int rr = NIT; rr--;)\r\n\t\t\t{\r\n\t\t\t\tz_oldt = zt;\r\n\t\t\t\tstd::tie(std::ignore, sigma_2, theta_p) = principal_sigma(zt, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t\t\tsigmat = abs(sigma_2) * exp(dcomp(0, 1) * (theta_p + pi_val));\r\n\t\t\t\tz11 = z + (sigma + sigmat) / abs(sigma) * dy1;\r\n\t\t\t\teta = angel_change(z11, z, z_old);\r\n\t\t\t\tif (eta > pi_val && jj > 1) {\r\n\t\t\t\t\tdy1 = -dy1;\r\n\t\t\t\t}\r\n\t\t\t\tzt = z + (sigma + sigmat) / abs(sigma + sigmat) * dy1;\r\n\t\t\t\tee = std::norm(z_oldt - zt);\r\n\t\t\t\tif (ee < cond)\r\n\t\t\t\t{\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\ttraj_2[kk][jj] = zt;\r\n\t\t\tz_old = z;\r\n\t\t\tz = zt;\r\n\t\t}\r\n\t}\r\n\treturn { traj_1, traj_2 };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tW UNIFORM STRESS\r\n-----------------------------------------------------------------------*/\r\ninline dcomp w_uni(dcomp z, double kappa, double G, double sigma_11inf)\r\n{\r\n\t// Defining the variables\r\n\tdcomp phi_bar, dphi, psi, w;\r\n\r\n\t// calculating the veriables\r\n\tphi_bar = -0.5 * sigma_11inf * conj(z);\r\n\tdphi = -0.5 * sigma_11inf;\r\n\tpsi = -0.5 * sigma_11inf * z;\r\n\r\n\t// Calculating w\r\n\tw = 1 / (4 * G) * ((z - conj(z)) * dphi + kappa * phi_bar + psi);\r\n\r\n\treturn { w };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tW CRACK - ANALYTIC ELEMENT\r\n-----------------------------------------------------------------------*/\r\ninline dcomp w_crack(dcomp z, double kappa, double G, dcomp z1, dcomp z2, double L, double mu, int m, dcvec a)\r\n{\r\n\t// Defining the variables\r\n\tdcomp chi, chi_bar, Z, chi_pow;\r\n\tdcomp dphi, phi_bar, psi;\r\n\tdcomp w, L_frac;\r\n\tdouble n;\r\n\r\n\t// Getting the chi - and Z - coordinates\r\n\tchi = chi_from_z(z, z1, z2, L, mu);\r\n\tchi_bar = conj(chi);\r\n\tZ = exp(dcomp(0, -1) * mu) * 2.0 * (z - 0.5 * (z1 + z2)) / L;\r\n\r\n\t// Calculating the series\r\n\tphi_bar = 0;\r\n\tdphi = 0;\r\n\tpsi = 0;\r\n\tn = 0;\r\n\tchi_pow = chi * chi - 1.0;\r\n\tfor (int ii = 0; ii < m; ii++)\r\n\t{\r\n\t\tdcomp a_n;\r\n\t\tn += 1;\r\n\t\ta_n = a[ii] * n;\r\n\t\tdphi += conj(a_n) * pow(chi, (1.0 - n)) / chi_pow;\r\n\t\tphi_bar -= a[ii] * pow(chi_bar, -n);\r\n\t\tpsi += a[ii] * pow(chi, -n);\r\n\t}\r\n\r\n\t// Multiplying the constants\r\n\tL_frac = (4.0 / L) * exp(dcomp(0, -1) * mu);\r\n\tdphi *= L_frac;\r\n\r\n\t// Calcualting w\r\n\tw = 1 / (4 * G) * (0.5 * L * (Z - conj(Z)) * exp(dcomp(0, 1) * mu) * dphi + kappa * phi_bar + psi);\r\n\r\n\treturn { w };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tW TOTAL\r\n-----------------------------------------------------------------------*/\r\ninline dcomp w_total(dcomp z, double kappa, double G, double sigma_11inf, dcvec z1a, dcvec z2a, dvec La, dvec mua, int ma, int na, ddcvec a)\r\n{\r\n\t// Defining the variables\r\n\tdcomp w, wg;\r\n\r\n\t// Add the unfirm stress field\r\n\tw = w_uni(z, kappa, G, sigma_11inf);\r\n\r\n\t// Add the anlytic element for a crack\r\n\tif (na > 0)\r\n\t{\r\n\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t{\r\n\t\t\tdcomp wc;\r\n\t\t\twc = w_crack(z, kappa, G, z1a[ii], z2a[ii], La[ii], mua[ii], ma, a[ii]);\r\n\t\t\tw += wc * exp(dcomp(0, -1) * mua[ii]);\r\n\t\t}\r\n\t}\r\n\r\n\treturn { w };\r\n}\r\n/* --------------------------------------------------------------------\r\n\t\tDISPLACEMENT FIELD\r\n-----------------------------------------------------------------------*/\r\nstd::tuple w_field(double xfrom, double xto, double yfrom, double yto, int Nw, double kappa, double G, double sigma_11inf, dcvec z1a, dcvec z2a, dvec La, dvec mua, int ma, int na, ddcvec a)\r\n\r\n{\r\n\t// Defining the variables\r\n\tddcvec grid_w(Nw, dcvec(Nw));\r\n\tdvec x_vecw(Nw), y_vecw(Nw);\r\n\tdouble dx;\r\n\tdouble dy;\r\n\r\n\t// Calcualte the displacement grid\r\n\tdx = (xto - xfrom) / (Nw - 1.0);\r\n\tdy = (yto - yfrom) / (Nw - 1.0);\r\n#pragma omp parallel for default(none) shared(grid_w, x_vecw, y_vecw, kappa, G, sigma_11inf, z1a, z2a, La, mua, ma, na, a)\r\n\tfor (int ii = 0; ii < Nw; ii++)\r\n\t{\r\n\t\tfor (int jj = 0; jj < Nw; jj++)\r\n\t\t{\r\n\r\n\t\t\tx_vecw[ii] = xfrom + ii * dx;\r\n\t\t\ty_vecw[jj] = yfrom + jj * dy;\r\n\t\t\tgrid_w[ii][jj] = w_total(dcomp(x_vecw[ii], y_vecw[jj]), kappa, G, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t}\r\n\t}\r\n\treturn { x_vecw, y_vecw, grid_w };\r\n}\r\n/*---------------------------------------------------------------------\r\n\t\tDISPLACEMENT TRAJECTORIES\r\n-----------------------------------------------------------------------*/\r\nddcvec w_trajectories(double xfrom, double xto, double yfrom, double yto, int Ntraj, int Nw, double kappa, double G, double sigma_11inf, dcvec z1a, dcvec z2a, dvec La, dvec mua, int ma, int na, ddcvec a)\r\n{\r\n\t// Defining the variables\r\n\tddcvec traj_w((int)(Nw * 2), dcvec(Ntraj));\r\n\tdouble dx, dy_lvs;\r\n\tdouble cond, pi_val;\r\n\tint NIT;\r\n\r\n\t// Getting the starting points\r\n\tdx = (xto - xfrom) / (Ntraj);\r\n\tdy_lvs = (yto - yfrom) / (Nw - 1.0);\r\n\tpi_val = 0.5 * pi();\r\n\tcond = 1e-6;\r\n\tNIT = 10;\r\n\r\n\t// w trajectories\r\n#pragma omp parallel for default(none) shared(traj_w, kappa, G, sigma_11inf, z1a, z2a, La, mua, ma, na, a)\r\n\tfor (int ii = 0; ii < Nw; ii++)\r\n\t{\r\n\t\ttraj_w[ii][0] = dcomp(xfrom, yfrom + ii * dy_lvs);\r\n\t\tdcomp z = traj_w[ii][0];\r\n\t\tdcomp z_old = z;\r\n\t\tdouble dx1 = dx;\r\n\t\tfor (int jj = 1; jj < Ntraj; jj++)\r\n\t\t{\r\n\t\t\tdcomp zt, z_oldt, w, w1;\r\n\t\t\tdouble ee;\r\n\t\t\tw = w_total(z, kappa, G, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t\tzt = z + conj(w) / abs(w) * dx1;\r\n\r\n\t\t\tee = 1;\r\n\t\t\tfor (int rr = NIT; rr--;)\r\n\t\t\t{\r\n\t\t\t\tz_oldt = zt;\r\n\t\t\t\tw1 = w_total(zt, kappa, G, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t\t\tzt = z + conj(w + w1) / abs(w + w1) * dx1;\r\n\t\t\t\tee = std::norm(z_oldt - zt);\r\n\t\t\t\tif (ee < cond)\r\n\t\t\t\t{\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\ttraj_w[ii][jj] = zt;\r\n\t\t\tz_old = z;\r\n\t\t\tz = zt;\r\n\t\t}\r\n\r\n\t\tint kk = ii + Nw;\r\n\t\ttraj_w[kk][0] = dcomp(xto, yfrom + ii * dy_lvs);\r\n\t\tz = traj_w[kk][0];\r\n\t\tz_old = z;\r\n\t\tdx1 = dx;\r\n\t\tfor (int jj = 1; jj < Ntraj; jj++)\r\n\t\t{\r\n\t\t\tdcomp zt, z_oldt, w, w1;\r\n\t\t\tdouble ee;\r\n\t\t\tw = w_total(z, kappa, G, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t\tzt = z + conj(w) / abs(w) * dx1;\r\n\r\n\t\t\tee = 1;\r\n\t\t\tfor (int rr = NIT; rr--;)\r\n\t\t\t{\r\n\t\t\t\tz_oldt = zt;\r\n\t\t\t\tw1 = w_total(zt, kappa, G, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\t\t\t\tzt = z + conj(w + w1) / abs(w + w1) * dx1;\r\n\t\t\t\tee = std::norm(z_oldt - zt);\r\n\t\t\t\tif (ee < cond)\r\n\t\t\t\t{\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\ttraj_w[kk][jj] = zt;\r\n\t\t\tz_old = z;\r\n\t\t\tz = zt;\r\n\r\n\t\t}\r\n\t}\r\n\treturn { traj_w };\r\n}\r\n\r\n/* --------------------------------------------------------------------\r\n\r\n\t\tMAIN SCRIPT\r\n\r\n-----------------------------------------------------------------------*/\r\nint main()\r\n{\r\n\t/* --------------------------------------------------------------------\r\n\t\t\tDefining variables and importing data\r\n\t-----------------------------------------------------------------------*/\r\n\r\n\t// Header in console window\r\n\tauto start = std::chrono::high_resolution_clock::now(); // Start the clock\r\n\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\tstd::cout << \"\t\tANALYTIC ELEMENT LINEAR ELASTIC SOLVER\t\" << std::endl << std::endl;\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\r\n\tauto date_time1 = std::chrono::system_clock::now();\r\n\tstd::time_t start_time = std::chrono::system_clock::to_time_t(date_time1);\r\n\tchar str_time1[26];\r\n\tctime_s(str_time1, sizeof str_time1, &start_time);\r\n\tstd::cout << \"Program started: \" << str_time1 << std::endl;\r\n\r\n\t// Setting the data types\r\n\tdcomp z;\r\n\tdouble kappa, sigma_11inf, G, cond;\r\n\tint na, ma, Na, NIT;\r\n\r\n\t// Read the input data from binary file PART 1\r\n\tstd::ifstream input_file(\"geometry_data.bin\", std::ios::in | std::ios::binary | std::ios::ate);\r\n\tstd::streampos size = input_file.tellg();\r\n\tchar* memblock = new char[size];\r\n\tinput_file.seekg(0, std::ios::beg);\r\n\tinput_file.read(memblock, size);\r\n\tdouble* fin = (double*)memblock;//reinterpret as doubles\r\n\r\n\tsigma_11inf = fin[0];\r\n\tkappa = fin[1];\r\n\tG = fin[2];\r\n\tna = (int)fin[3];\r\n\tma = (int)fin[4];\r\n\tNa = (int)fin[5];\r\n\tcond = (double)fin[6];\r\n\tNIT = (int)fin[7];\r\n\r\n\t// Declaring the vecotrs\r\n\tdcvec z1a(na), z2a(na);\r\n\tdvec pa(na), La(na), mua(na);\r\n\tddcvec a(na, dcvec(ma));\r\n\r\n\tint pos = 7 + 1;\r\n\tif (na > 0)\r\n\t{\r\n\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t{\r\n\t\t\tint re = pos + ii;\r\n\t\t\tint im = pos + na + ii;\r\n\t\t\tz1a[ii] = dcomp(fin[re], fin[im]);\r\n\t\t}\r\n\t\tpos += 2 * na;\r\n\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t{\r\n\t\t\tint re = pos + ii;\r\n\t\t\tint im = pos + na + ii;\r\n\t\t\tz2a[ii] = dcomp(fin[re], fin[im]);\r\n\t\t}\r\n\t\tpos += 2 * na;\r\n\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t{\r\n\t\t\tpa[ii] = fin[pos + ii];\r\n\t\t}\r\n\t\tpos += na;\r\n\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t{\r\n\t\t\tLa[ii] = fin[pos + ii];\r\n\t\t}\r\n\t\tpos += na;\r\n\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t{\r\n\t\t\tmua[ii] = fin[pos + ii];\r\n\t\t}\r\n\t\tpos += na;\r\n\t}\r\n\telse\r\n\t{\r\n\t\tz1a = { dcomp(0, 0) };\r\n\t\tz2a = { dcomp(0, 0) };\r\n\t\tLa = { 0 };\r\n\t\tmua = { 0 };\r\n\t\ta = { { dcomp(0,0) } };\r\n\t\tma = 1;\r\n\t\tNa = 1;\r\n\t}\r\n\r\n\t// Setting the data types\r\n\tdouble xfrom, xto, yfrom, yto;\r\n\tint Nx, Ny, Nw, Ntraj, lvs_traj;\r\n\tddvec grid_11, grid_22, grid_12, grid_1, grid_2, theta_p;\r\n\tddcvec traj_1, traj_2, grid_w, traj_w;\r\n\tdvec x_vec, y_vec, x_vecw, y_vecw;\r\n\tdcvec xtraj, ytraj;\r\n\r\n\t// Read the plot data from binary file\r\n\tstd::ifstream plot_file(\"plot_data.bin\", std::ios::in | std::ios::binary | std::ios::ate);\r\n\tstd::streampos size2 = plot_file.tellg();\r\n\tchar* memblock2 = new char[size2];\r\n\tplot_file.seekg(0, std::ios::beg);\r\n\tplot_file.read(memblock2, size2);\r\n\tdouble* fplot = (double*)memblock2;//reinterpret as doubles\r\n\r\n\txfrom = fplot[0];\r\n\txto = fplot[1];\r\n\tyfrom = fplot[2];\r\n\tyto = fplot[3];\r\n\tNx = (int)fplot[4];\r\n\tNy = (int)fplot[5];\r\n\tNw = (int)fplot[6];\r\n\tNtraj = (int)fplot[7];\r\n\tlvs_traj = (int)fplot[8];\r\n\txtraj = { fplot[9] + dcomp(0,1) * fplot[10], fplot[11] + dcomp(0,1) * fplot[12] };\r\n\tytraj = { fplot[13] + dcomp(0,1) * fplot[14], fplot[15] + dcomp(0,1) * fplot[16] };\r\n\r\n\t// Displying the plot data in the command window\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\tstd::cout << \"\t\tTHE GEOMETRY DATA\t\" << std::endl << std::endl;\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\tstd::cout << \"This is the retrived geometry data:\\n\";\r\n\tstd::cout << \"sigma_11inf = \" << sigma_11inf << std::endl;\r\n\tstd::cout << \" kappa = \" << kappa << std::endl;\r\n\tstd::cout << \" G = \" << G << std::endl;\r\n\tstd::cout << \" na = \" << na << std::endl;\r\n\tstd::cout << \" ma = \" << ma << std::endl;\r\n\tstd::cout << \" Na = \" << Na << std::endl;\r\n\t// Displying the plot data in the command window\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\tstd::cout << \"\t\tTHE READ PLOT DATA\t\" << std::endl << std::endl;\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\tstd::cout << \"This is the retrived plot data:\\n\";\r\n\tstd::cout << \"x from: \" << xfrom << \" to \" << xto << std::endl;\r\n\tstd::cout << \"y from: \" << yfrom << \" to \" << yto << std::endl;\r\n\tstd::cout << \"x resolution: \" << Nx << std::endl;\r\n\tstd::cout << \"y resolution: \" << Ny << std::endl;\r\n\tstd::cout << \"Total number of points: \" << Nx * Ny << std::endl;\r\n\tstd::cout << \"Number of steps in trajectories: \" << Ntraj << std::endl;\r\n\tstd::cout << \"Number of trajectory levels: \" << lvs_traj << std::endl;\r\n\tstd::cout << \"Total number of trajectory points: \" << Ntraj * lvs_traj * 4 << std::endl;\r\n\tstd::cout << \"sigma_1 starting line from: \" << xtraj[0] << \" to \" << xtraj[1] << std::endl;\r\n\tstd::cout << \"sigma_2 starting line from: \" << ytraj[0] << \" to \" << ytraj[1] << std::endl;\r\n\tstd::cout << \"x and y quiver resolution: \" << Nw << std::endl << std::endl;\r\n\tstd::cout << std::endl;\r\n\r\n\t/* --------------------------------------------------------------------\r\n\t\t\tSolve the system\r\n\t-----------------------------------------------------------------------*/\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\tstd::cout << \"\t\tINITIALIZING THE SOVLER\t\" << std::endl << std::endl;\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\r\n\tauto start_solv = std::chrono::high_resolution_clock::now();\r\n\ta = iterator(cond, NIT, Na, pa, sigma_11inf, z1a, z2a, La, mua, ma, na);\r\n\tauto stop_solv = std::chrono::high_resolution_clock::now();\r\n\tauto duration_solv = std::chrono::duration_cast(stop_solv - start_solv);\r\n\r\n\t// Displaying the computation time\r\n\tstd::cout << std::endl;\r\n\tlong long ms_solv = duration_solv.count();\r\n\tlong long s_solv, m_solv, h_solv;\r\n\tstd::tie(ms_solv, s_solv, m_solv, h_solv) = ms_to_time(ms_solv);\r\n\tstd::cout << \"Computations finnished after \";\r\n\ttime_print(ms_solv, s_solv, m_solv, h_solv);\r\n\r\n\tstd::cout << std::endl;\r\n\r\n\t/* --------------------------------------------------------------------\r\n\t\t\tChecking the error\r\n\t-----------------------------------------------------------------------*/\r\n\tdouble error_med_a_re{}, error_mean_a_re{}, error_max_a_re{}, error_med_a_im{}, error_mean_a_im{}, error_max_a_im{}, error_med_int{}, error_mean_int{}, error_max_int{};\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\tstd::cout << \"\t\tERRORS\t\" << std::endl << std::endl;\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\tint numa;\r\n\tnuma = (int)round(Na);\r\n\tdcvec T_check(numa* na);\r\n\tif (na > 0)\r\n\t{\r\n\t\t// Calculate the error along the cracks, i.e. T = t_s + i*t_n = 0 + i*p\r\n\t\tdvec T_check_a_re(numa * na), T_check_a_im(numa * na);\r\n\t\tdouble theta_0a = pi()/numa;\r\n\t\tdouble delthetaa = (pi() - 2.0*theta_0a) / (numa-1.0);\r\n\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t{\r\n\t\t\tfor (int jj = 0; jj < numa; jj++)\r\n\t\t\t{\r\n\t\t\t\tdcomp z, tau_11, tau_12;\r\n\t\t\t\tdouble theta;\r\n\t\t\t\ttheta = theta_0a + (jj) * delthetaa;\r\n\t\t\t\tz = z_from_chi(exp(dcomp(0, 1) * theta), z1a[ii], z2a[ii], La[ii], mua[ii]);\r\n\t\t\t\tT_check[(ii * numa) + jj] = T_total(z, sigma_11inf, z1a, z2a, La, mua, ma, na, a, -1, ii) + dcomp(0, pa[ii]);\r\n\t\t\t\tT_check_a_re[(ii * numa) + jj] = abs(real(T_check[(ii * numa) + jj]));\r\n\t\t\t\tT_check_a_im[(ii * numa) + jj] = abs(imag(T_check[(ii * numa) + jj]));\r\n\t\t\t}\r\n\t\t}\r\n\t\t// Median\r\n\t\tsize_t n1 = T_check_a_re.size() / 2;\r\n\t\tnth_element(T_check_a_re.begin(), T_check_a_re.begin() + n1, T_check_a_re.end());\r\n\t\terror_med_a_re = T_check_a_re[n1];\r\n\t\tnth_element(T_check_a_im.begin(), T_check_a_im.begin() + n1, T_check_a_im.end());\r\n\t\terror_med_a_im = T_check_a_im[n1];\r\n\t\t// Mean\r\n\t\terror_mean_a_re = 1.0 * std::accumulate(T_check_a_re.begin(), T_check_a_re.end(), 0.0) / (n1 * 2);\r\n\t\terror_mean_a_im = 1.0 * std::accumulate(T_check_a_im.begin(), T_check_a_im.end(), 0.0) / (n1 * 2);\r\n\t\t// Max\r\n\t\terror_max_a_re = *max_element(T_check_a_re.begin(), T_check_a_re.end());\r\n\t\terror_max_a_im = *max_element(T_check_a_im.begin(), T_check_a_im.end());\r\n\t\t// Print the results\r\n\t\tstd::cout << \" Analytic Element for a Crack\" << std::endl;\r\n\t\tstd::cout << \" Difference for ts\" << std::endl;\r\n\t\tstd::cout << \" Maximum = \" << error_max_a_re << std::endl;\r\n\t\tstd::cout << \" Mean = \" << error_mean_a_re << std::endl;\r\n\t\tstd::cout << \" Median = \" << error_med_a_re << std::endl;\r\n\t\tstd::cout << \" Difference for tn\" << std::endl;\r\n\t\tstd::cout << \" Maximum = \" << error_max_a_im << std::endl;\r\n\t\tstd::cout << \" Mean = \" << error_mean_a_im << std::endl;\r\n\t\tstd::cout << \" Median = \" << error_med_a_im << std::endl;\r\n\r\n\t\t// Error at the intersection\r\n\t\tddcvec zint(na, dcvec(na));\r\n\t\tiivec int_check(na, ivec(na));\r\n\t\tivec int_count(na);\r\n\r\n\t\t// Find the intersection points\r\n\t\t#pragma omp parallel for default(none) shared(zint, int_check, int_count, z1a, z2a)\r\n\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t{\r\n\t\t\tfor (int jj = 0; jj < na; jj++)\r\n\t\t\t{\r\n\t\t\t\tstd::tie(zint[ii][jj], int_check[ii][jj]) = intersection_point(z1a[ii], z2a[ii], z1a[jj], z2a[jj]);\r\n\t\t\t}\r\n\t\t\tint_count[ii] = std::accumulate(int_check[ii].begin(), int_check[ii].end(), 0.0);\r\n\t\t}\r\n\t\tint int_sum = std::accumulate(int_count.begin(), int_count.end(), 0.0);\r\n\t\tdvec int_error(int_sum);\r\n\t\tint cnt_int = 0;\r\n\r\n\t\t// Calcualte the error at the intersections, i.e. real(tau^11) = 0\r\n\t\tif (int_sum > 0)\r\n\t\t{\r\n\t\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t\t{\r\n\t\t\t\tif (int_count[ii] > 0)\r\n\t\t\t\t{\r\n\t\t\t\t\tint cnt_er = 0;\r\n\t\t\t\t\tfor (int jj = 0; jj < na; jj++)\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif (int_check[ii][jj] == 1)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tdcomp tau_11, tau_12, T;\r\n\t\t\t\t\t\t\tstd::tie(tau_11, tau_12) = tau_total(zint[ii][jj], sigma_11inf, z1a, z2a, La, mua, ma, na, a, -1);\r\n\t\t\t\t\t\t\tT = T_total(z, sigma_11inf, z1a, z2a, La, mua, ma, na, a, -1, ii);\r\n\t\t\t\t\t\t\tstd::cout << \"z = \" << zint[ii][jj] << \" tau_11 = \" << tau_11 << \" tau_12 = \" << tau_12 << \" T = \" << T << std::endl;\r\n\t\t\t\t\t\t\tint_error[cnt_int + cnt_er] = abs(real(tau_11));\r\n\t\t\t\t\t\t\tcnt_er += 1;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tcnt_int += int_count[ii];\r\n\t\t\t}\r\n\r\n\t\t\t// Mean\r\n\t\t\terror_mean_int = std::accumulate(int_error.begin(), int_error.end(), 0.0) / (int_sum);\r\n\t\t\t// Max\r\n\t\t\terror_max_int = *max_element(int_error.begin(), int_error.end());\r\n\t\t\t// Median\r\n\t\t\tsize_t n2 = int_error.size() / 2;\r\n\t\t\tnth_element(int_error.begin(), int_error.begin() + n2, int_error.end());\r\n\t\t\terror_med_int = int_error[n2];\r\n\t\t\t// Print the results\r\n\t\t\tstd::cout << \" Intersection/s:\" << std::endl;\r\n\t\t\tstd::cout << \" Maximum = \" << error_max_int << std::endl;\r\n\t\t\tstd::cout << \" Mean = \" << error_mean_int << std::endl;\r\n\t\t\tstd::cout << \" Median = \" << error_med_int << std::endl;\r\n\t\t}\r\n\t}\r\n\r\n\t// Create/open the two output files\r\n\tstd::ofstream outfile_coef(\"input_data.bin\", std::ios::out | std::ios::binary);\r\n\r\n\t// Save the plot properties\r\n\tdvec prop = { sigma_11inf, kappa, G, 1.0 * na, 1.0 * ma};\r\n\tconst char* pointerprop = reinterpret_cast(&prop[0]);\r\n\tstd::size_t bytesprop = prop.size() * sizeof(prop[0]);\r\n\toutfile_coef.write(pointerprop, bytesprop);\r\n\r\n\r\n\t// saving the coordinates of the cracks\r\n\tif (na > 0)\r\n\t{\r\n\t\tdvec fz1_re(na);\r\n\t\tdvec fz1_im(na);\r\n\t\tfor (int jj = 0; jj < na; jj++)\r\n\t\t{\r\n\t\t\tfz1_re[jj] = real(z1a[jj]);\r\n\t\t\tfz1_im[jj] = imag(z1a[jj]);\r\n\t\t}\r\n\t\tconst char* pointerz1_re = reinterpret_cast(&fz1_re[0]);\r\n\t\tstd::size_t bytesz1_re = fz1_re.size() * sizeof(fz1_re[0]);\r\n\t\toutfile_coef.write(pointerz1_re, bytesz1_re);\r\n\t\tconst char* pointerz1_im = reinterpret_cast(&fz1_im[0]);\r\n\t\tstd::size_t bytesz1_im = fz1_im.size() * sizeof(fz1_im[0]);\r\n\t\toutfile_coef.write(pointerz1_im, bytesz1_im);\r\n\r\n\t\tdvec fz2_re(na);\r\n\t\tdvec fz2_im(na);\r\n\t\tfor (int jj = 0; jj < na; jj++)\r\n\t\t{\r\n\t\t\tfz2_re[jj] = real(z2a[jj]);\r\n\t\t\tfz2_im[jj] = imag(z2a[jj]);\r\n\t\t}\r\n\t\tconst char* pointerz2_re = reinterpret_cast(&fz2_re[0]);\r\n\t\tstd::size_t bytesz2_re = fz2_re.size() * sizeof(fz2_re[0]);\r\n\t\toutfile_coef.write(pointerz2_re, bytesz2_re);\r\n\t\tconst char* pointerz2_im = reinterpret_cast(&fz2_im[0]);\r\n\t\tstd::size_t bytesz2_im = fz2_im.size() * sizeof(fz2_im[0]);\r\n\t\toutfile_coef.write(pointerz2_im, bytesz2_im);\r\n\r\n\t\tdvec fL = La;\r\n\t\tconst char* pointerL = reinterpret_cast(&fL[0]);\r\n\t\tstd::size_t bytesL = fL.size() * sizeof(fL[0]);\r\n\t\toutfile_coef.write(pointerL, bytesL);\r\n\r\n\t\tdvec fmu = mua;\r\n\t\tconst char* pointermu = reinterpret_cast(&fmu[0]);\r\n\t\tstd::size_t bytesmu = fmu.size() * sizeof(fmu[0]);\r\n\t\toutfile_coef.write(pointermu, bytesmu);\r\n\r\n\t\t// Save the a\r\n\t\tfor (int ii = 0; ii < na; ii++)\r\n\t\t{\r\n\t\t\tdvec fbeta_re(ma);\r\n\t\t\tdvec fbeta_im(ma);\r\n\r\n\t\t\tfor (int jj = 0; jj < ma; jj++)\r\n\t\t\t{\r\n\t\t\t\tfbeta_re[jj] = real(a[ii][jj]);\r\n\t\t\t\tfbeta_im[jj] = imag(a[ii][jj]);\r\n\t\t\t}\r\n\t\t\tconst char* pointerbeta_re = reinterpret_cast(&fbeta_re[0]);\r\n\t\t\tstd::size_t bytesbeta_re = fbeta_re.size() * sizeof(fbeta_re[0]);\r\n\t\t\toutfile_coef.write(pointerbeta_re, bytesbeta_re);\r\n\t\t\tconst char* pointerbeta_im = reinterpret_cast(&fbeta_im[0]);\r\n\t\t\tstd::size_t bytesbeta_im = fbeta_im.size() * sizeof(fbeta_im[0]);\r\n\t\t\toutfile_coef.write(pointerbeta_im, bytesbeta_im);\r\n\t\t}\r\n\t}\r\n\r\n\t// Estimate the time of the program\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\tstd::cout << \"\t\tESTIMATED CALCULATION TIME\t\" << std::endl << std::endl;\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\tint Ne = (Nx + Ny + Ntraj) / 100;\r\n\tif (Ne < 8)\r\n\t{\r\n\t\tNe = 8;\r\n\t}\r\n\tauto start0 = std::chrono::high_resolution_clock::now();\r\n\tstress_field(xfrom, xto, yfrom, yto, Ne, Ne, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\tauto stop0 = std::chrono::high_resolution_clock::now();\r\n\tauto start01 = std::chrono::high_resolution_clock::now();\r\n\tprincipal_stress_trajectories(xfrom, xto, yfrom, yto, xtraj, ytraj, Ne, Ne, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\tauto stop01 = std::chrono::high_resolution_clock::now();\r\n\tauto duration0 = std::chrono::duration_cast(stop0 - start0);\r\n\tlong long ms0 = duration0.count();\r\n\tauto duration01 = std::chrono::duration_cast(stop01 - start01);\r\n\tlong long ms01 = duration01.count();\r\n\tlong long calcs0 = (int)(2 * Nx * Ny) + (int)(Nw * Nw);\r\n\tlong long calcs01 = (int)(Ntraj * lvs_traj) + (int)(Ntraj * Nw);\r\n\tms0 = ((ms0 / ((int)Ne * Ne) * calcs0 + ms01 / ((int)Ne * Ne) * calcs01))*0.7;\r\n\tlong long s0, m0, h0;\r\n\tstd::tie(ms0, s0, m0, h0) = ms_to_time(ms0);\r\n\tstd::cout << \"Estimated calculation time: \";\r\n\ttime_print(ms0, s0, m0, h0);\r\n\tstd::cout << std::endl << std::endl;\r\n\tauto date_time2 = std::chrono::system_clock::now();\r\n\tstd::time_t start_time2 = std::chrono::system_clock::to_time_t(date_time2);\r\n\tchar str_time2[26];\r\n\tctime_s(str_time2, sizeof str_time2, &start_time2);\r\n\tstd::cout << \"Plotting started: \" << str_time2 << std::endl << std::endl;\r\n\r\n\t/* --------------------------------------------------------------------\r\n\t\t\tCalculating the plots\r\n\t-----------------------------------------------------------------------*/\r\n\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\tstd::cout << \"\t\tCOMPUTING THE PLOTS\t\" << std::endl << std::endl;\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\r\n\t// Get the Cartisian stress field\r\n\tstd::cout << \"Initiating the stress field calculation\\n\";\r\n\tauto start1 = std::chrono::high_resolution_clock::now();\r\n\tstd::tie(x_vec, y_vec, grid_11, grid_22, grid_12) = stress_field(xfrom, xto, yfrom, yto, Nx, Ny, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\tauto stop1 = std::chrono::high_resolution_clock::now();\r\n\tauto duration1 = std::chrono::duration_cast(stop1 - start1);\r\n\tstd::cout << \"Completed, time taken by function: stress_field = \";\r\n\tlong long ms1, s1, m1, h1;\r\n\tms1 = duration1.count();\r\n\tstd::tie(ms1, s1, m1, h1) = ms_to_time(ms1);\r\n\ttime_print(ms1, s1, m1, h1);\r\n\tstd::cout << std::endl << std::endl;\r\n\r\n\t// Get the principal stress field\r\n\tstd::cout << \"Initiating the principal stress field calculation\\n\";\r\n\tauto start2 = std::chrono::high_resolution_clock::now();\r\n\tstd::tie(grid_1, grid_2, theta_p) = principal_stress_field(Nx, Ny, grid_11, grid_22, grid_12);\r\n\tauto stop2 = std::chrono::high_resolution_clock::now();\r\n\tauto duration2 = std::chrono::duration_cast(stop2 - start2);\r\n\tstd::cout << \"Completed, time taken by function: principal_stress_field = \";\r\n\tms1 = duration2.count();\r\n\tstd::tie(ms1, s1, m1, h1) = ms_to_time(ms1);\r\n\ttime_print(ms1, s1, m1, h1);\r\n\tstd::cout << std::endl << std::endl;\r\n\r\n\t// Get the stress trajectories\r\n\tstd::cout << \"Initiating the principal stress trajectories calculation\\n\";\r\n\tauto start3 = std::chrono::high_resolution_clock::now();\r\n\tstd::tie(traj_1, traj_2) = principal_stress_trajectories(xfrom, xto, yfrom, yto, xtraj, ytraj, Ntraj, lvs_traj, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\tauto stop3 = std::chrono::high_resolution_clock::now();\r\n\tauto duration3 = std::chrono::duration_cast(stop3 - start3);\r\n\tstd::cout << \"Completed, time taken by function: principal_stress_trajectories = \";\r\n\tms1 = duration3.count();\r\n\tstd::tie(ms1, s1, m1, h1) = ms_to_time(ms1);\r\n\ttime_print(ms1, s1, m1, h1);\r\n\tstd::cout << std::endl << std::endl;\r\n\r\n\t// Get the displacement field\r\n\tstd::cout << \"Initiating the displacement field calculation\\n\";\r\n\tauto start4 = std::chrono::high_resolution_clock::now();\r\n\tstd::tie(x_vecw, y_vecw, grid_w) = w_field(xfrom, xto, yfrom, yto, Nw, kappa, G, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\tauto stop4 = std::chrono::high_resolution_clock::now();\r\n\tauto duration4 = std::chrono::duration_cast(stop4 - start4);\r\n\tstd::cout << \"Completed, time taken by function: w_field = \";\r\n\tms1 = duration4.count();\r\n\tstd::tie(ms1, s1, m1, h1) = ms_to_time(ms1);\r\n\ttime_print(ms1, s1, m1, h1);\r\n\tstd::cout << std::endl << std::endl;\r\n\r\n\r\n\t// Get the displacement trajectories\r\n\tstd::cout << \"Initiating the displacement trajectories calculation\\n\";\r\n\tauto start5 = std::chrono::high_resolution_clock::now();\r\n\ttraj_w = w_trajectories(xfrom, xto, yfrom, yto, Ntraj, Nw, kappa, G, sigma_11inf, z1a, z2a, La, mua, ma, na, a);\r\n\tauto stop5 = std::chrono::high_resolution_clock::now();\r\n\tauto duration5 = std::chrono::duration_cast(stop5 - start5);\r\n\tstd::cout << \"Completed, time taken by function: w_trajectories = \";\r\n\tms1 = duration5.count();\r\n\tstd::tie(ms1, s1, m1, h1) = ms_to_time(ms1);\r\n\ttime_print(ms1, s1, m1, h1);\r\n\tstd::cout << std::endl << std::endl;\r\n\r\n\t// Displaying the computation time\r\n\tstd::cout << \"=================================================================\" << std::endl << std::endl;\r\n\tlong long mstime = duration1.count() + duration2.count() + duration3.count() + duration4.count() + duration5.count();\r\n\tlong long stime, mtime, htime;\r\n\tstd::tie(mstime, stime, mtime, htime) = ms_to_time(mstime);\r\n\tstd::cout << \"Total calculation time: \";\r\n\ttime_print(mstime, stime, mtime, htime);\r\n\tstd::cout << std::endl << std::endl;\r\n\r\n\t/* --------------------------------------------------------------------\r\n\t\t\tSaving the data as binary files\r\n\t-----------------------------------------------------------------------*/\r\n\r\n\t// Create/open the two output files\r\n\tstd::ofstream outfile(\"data.bin\", std::ios::out | std::ios::binary);\r\n\tstd::ofstream outfiledim(\"dim_data.bin\", std::ios::out | std::ios::binary);\r\n\r\n\t// Save the x and y vectors\r\n\tdvec fx = x_vec;\r\n\tconst char* pointerx = reinterpret_cast(&fx[0]);\r\n\tstd::size_t bytesx = fx.size() * sizeof(fx[0]);\r\n\toutfile.write(pointerx, bytesx);\r\n\r\n\tdvec fy = y_vec;\r\n\tconst char* pointery = reinterpret_cast(&fy[0]);\r\n\tstd::size_t bytesy = fy.size() * sizeof(fy[0]);\r\n\toutfile.write(pointery, bytesy);\r\n\r\n\tdvec fxw = x_vecw;\r\n\tconst char* pointerxw = reinterpret_cast(&fxw[0]);\r\n\tstd::size_t bytesxw = fxw.size() * sizeof(fxw[0]);\r\n\toutfile.write(pointerxw, bytesxw);\r\n\r\n\tdvec fyw = y_vecw;\r\n\tconst char* pointeryw = reinterpret_cast(&fyw[0]);\r\n\tstd::size_t bytesyw = fyw.size() * sizeof(fyw[0]);\r\n\toutfile.write(pointeryw, bytesyw);\r\n\r\n\t// Save the grids\r\n\tfor (size_t ii = 0; ii < grid_11.size(); ii++)\r\n\t{\r\n\t\tdvec fg11 = grid_11[ii];\r\n\t\tconst char* pointerg11 = reinterpret_cast(&fg11[0]);\r\n\t\tstd::size_t bytesg11 = fg11.size() * sizeof(fg11[0]);\r\n\t\toutfile.write(pointerg11, bytesg11);\r\n\t}\r\n\tfor (size_t ii = 0; ii < grid_22.size(); ii++)\r\n\t{\r\n\t\tdvec fg22 = grid_22[ii];\r\n\t\tconst char* pointerg22 = reinterpret_cast(&fg22[0]);\r\n\t\tstd::size_t bytesg22 = fg22.size() * sizeof(fg22[0]);\r\n\t\toutfile.write(pointerg22, bytesg22);\r\n\t}\r\n\tfor (size_t ii = 0; ii < grid_12.size(); ii++)\r\n\t{\r\n\t\tdvec fg12 = grid_12[ii];\r\n\t\tconst char* pointerg12 = reinterpret_cast(&fg12[0]);\r\n\t\tstd::size_t bytesg12 = fg12.size() * sizeof(fg12[0]);\r\n\t\toutfile.write(pointerg12, bytesg12);\r\n\t}\r\n\tfor (size_t ii = 0; ii < grid_1.size(); ii++)\r\n\t{\r\n\t\tdvec fg1 = grid_1[ii];\r\n\t\tconst char* pointerg1 = reinterpret_cast(&fg1[0]);\r\n\t\tstd::size_t bytesg1 = fg1.size() * sizeof(fg1[0]);\r\n\t\toutfile.write(pointerg1, bytesg1);\r\n\t}\r\n\tfor (size_t ii = 0; ii < grid_2.size(); ii++)\r\n\t{\r\n\t\tdvec fg2 = grid_2[ii];\r\n\t\tconst char* pointerg2 = reinterpret_cast(&fg2[0]);\r\n\t\tstd::size_t bytesg2 = fg2.size() * sizeof(fg2[0]);\r\n\t\toutfile.write(pointerg2, bytesg2);\r\n\t}\r\n\tfor (size_t ii = 0; ii < theta_p.size(); ii++)\r\n\t{\r\n\t\tdvec fgtp = theta_p[ii];\r\n\t\tconst char* pointergtp = reinterpret_cast(&fgtp[0]);\r\n\t\tstd::size_t bytesgtp = fgtp.size() * sizeof(fgtp[0]);\r\n\t\toutfile.write(pointergtp, bytesgtp);\r\n\t}\r\n\tfor (size_t ii = 0; ii < traj_1.size(); ii++)\r\n\t{\r\n\t\tdvec fgt1_re(Ntraj);\r\n\t\tdvec fgt1_im(Ntraj);\r\n\r\n\t\tfor (size_t jj = 0; jj < traj_1[0].size(); jj++)\r\n\t\t{\r\n\t\t\tfgt1_re[jj] = real(traj_1[ii][jj]);\r\n\t\t\tfgt1_im[jj] = imag(traj_1[ii][jj]);\r\n\t\t}\r\n\t\tconst char* pointergt1_re = reinterpret_cast(&fgt1_re[0]);\r\n\t\tstd::size_t bytesgt1_re = fgt1_re.size() * sizeof(fgt1_re[0]);\r\n\t\toutfile.write(pointergt1_re, bytesgt1_re);\r\n\t\tconst char* pointergt1_im = reinterpret_cast(&fgt1_im[0]);\r\n\t\tstd::size_t bytesgt1_im = fgt1_im.size() * sizeof(fgt1_im[0]);\r\n\t\toutfile.write(pointergt1_im, bytesgt1_im);\r\n\t}\r\n\tfor (size_t ii = 0; ii < traj_2.size(); ii++)\r\n\t{\r\n\t\tdvec fgt2_re(Ntraj);\r\n\t\tdvec fgt2_im(Ntraj);\r\n\t\tfor (size_t jj = 0; jj < traj_2[0].size(); jj++)\r\n\t\t{\r\n\t\t\tfgt2_re[jj] = real(traj_2[ii][jj]);\r\n\t\t\tfgt2_im[jj] = imag(traj_2[ii][jj]);\r\n\t\t}\r\n\t\tconst char* pointergt2_re = reinterpret_cast(&fgt2_re[0]);\r\n\t\tstd::size_t bytesgt2_re = fgt2_re.size() * sizeof(fgt2_re[0]);\r\n\t\toutfile.write(pointergt2_re, bytesgt2_re);\r\n\t\tconst char* pointergt2_im = reinterpret_cast(&fgt2_im[0]);\r\n\t\tstd::size_t bytesgt2_im = fgt2_im.size() * sizeof(fgt2_im[0]);\r\n\t\toutfile.write(pointergt2_im, bytesgt2_im);\r\n\t}\r\n\tfor (size_t ii = 0; ii < grid_w.size(); ii++)\r\n\t{\r\n\t\tdvec fgw_re(Nw);\r\n\t\tdvec fgw_im(Nw);\r\n\t\tfor (size_t jj = 0; jj < grid_w[0].size(); jj++)\r\n\t\t{\r\n\t\t\tfgw_re[jj] = real(grid_w[ii][jj]);\r\n\t\t\tfgw_im[jj] = imag(grid_w[ii][jj]);\r\n\t\t}\r\n\t\tconst char* pointergw_re = reinterpret_cast(&fgw_re[0]);\r\n\t\tstd::size_t bytesgw_re = fgw_re.size() * sizeof(fgw_re[0]);\r\n\t\toutfile.write(pointergw_re, bytesgw_re);\r\n\t\tconst char* pointergw_im = reinterpret_cast(&fgw_im[0]);\r\n\t\tstd::size_t bytesgw_im = fgw_im.size() * sizeof(fgw_im[0]);\r\n\t\toutfile.write(pointergw_im, bytesgw_im);\r\n\t}\r\n\tfor (size_t ii = 0; ii < traj_w.size(); ii++)\r\n\t{\r\n\t\tdvec fgtw_re(Ntraj);\r\n\t\tdvec fgtw_im(Ntraj);\r\n\t\tfor (size_t jj = 0; jj < traj_w[0].size(); jj++)\r\n\t\t{\r\n\t\t\tfgtw_re[jj] = real(traj_w[ii][jj]);\r\n\t\t\tfgtw_im[jj] = imag(traj_w[ii][jj]);\r\n\t\t}\r\n\t\tconst char* pointergtw_re = reinterpret_cast(&fgtw_re[0]);\r\n\t\tstd::size_t bytesgtw_re = fgtw_re.size() * sizeof(fgtw_re[0]);\r\n\t\toutfile.write(pointergtw_re, bytesgtw_re);\r\n\t\tconst char* pointergtw_im = reinterpret_cast(&fgtw_im[0]);\r\n\t\tstd::size_t bytesgtw_im = fgtw_im.size() * sizeof(fgtw_im[0]);\r\n\t\toutfile.write(pointergtw_im, bytesgtw_im);\r\n\t}\r\n\tif (na > 0)\r\n\t{\r\n\t\tdvec fT_res(numa * na);\r\n\t\tdvec fT_ims(numa * na);\r\n\t\tfor (int jj = 0; jj < numa * na; jj++)\r\n\t\t{\r\n\t\t\tfT_res[jj] = real(T_check[jj]);\r\n\t\t\tfT_ims[jj] = imag(T_check[jj]);\r\n\t\t}\r\n\t\tconst char* pointerT_res = reinterpret_cast(&fT_res[0]);\r\n\t\tstd::size_t bytesT_res = fT_res.size() * sizeof(fT_res[0]);\r\n\t\toutfile.write(pointerT_res, bytesT_res);\r\n\t\tconst char* pointerT_ims = reinterpret_cast(&fT_ims[0]);\r\n\t\tstd::size_t bytesT_ims = fT_ims.size() * sizeof(fT_ims[0]);\r\n\t\toutfile.write(pointerT_ims, bytesT_ims);\r\n\t}\r\n\t\r\n\r\n\t// Save the plot properties\r\n\tdvec dim = { 1.0 * Nx, 1.0 * Ny, 1.0 * Nw, 1.0 * Ntraj, 1.0 * lvs_traj, 1.0 * na, error_med_a_re, error_mean_a_re, error_max_a_re, error_med_a_im, error_mean_a_im, error_max_a_im, error_med_int, error_mean_int, error_max_int};\r\n\tconst char* pointerdim = reinterpret_cast(&dim[0]);\r\n\tstd::size_t bytesdim = dim.size() * sizeof(dim[0]);\r\n\toutfiledim.write(pointerdim, bytesdim);\r\n\r\n\t// saving the coordinates of the cracks\r\n\tif (na > 0)\r\n\t{\r\n\t\tdvec fz1_res(na);\r\n\t\tdvec fz1_ims(na);\r\n\t\tfor (int jj = 0; jj < na; jj++)\r\n\t\t{\r\n\t\t\tfz1_res[jj] = real(z1a[jj]);\r\n\t\t\tfz1_ims[jj] = imag(z1a[jj]);\r\n\t\t}\r\n\t\tconst char* pointerz1_res = reinterpret_cast(&fz1_res[0]);\r\n\t\tstd::size_t bytesz1_res = fz1_res.size() * sizeof(fz1_res[0]);\r\n\t\toutfiledim.write(pointerz1_res, bytesz1_res);\r\n\t\tconst char* pointerz1_ims = reinterpret_cast(&fz1_ims[0]);\r\n\t\tstd::size_t bytesz1_ims = fz1_ims.size() * sizeof(fz1_ims[0]);\r\n\t\toutfiledim.write(pointerz1_ims, bytesz1_ims);\r\n\r\n\t\tdvec fz2_res(na);\r\n\t\tdvec fz2_ims(na);\r\n\t\tfor (int jj = 0; jj < na; jj++)\r\n\t\t{\r\n\t\t\tfz2_res[jj] = real(z2a[jj]);\r\n\t\t\tfz2_ims[jj] = imag(z2a[jj]);\r\n\t\t}\r\n\t\tconst char* pointerz2_re = reinterpret_cast(&fz2_res[0]);\r\n\t\tstd::size_t bytesz2_re = fz2_res.size() * sizeof(fz2_res[0]);\r\n\t\toutfiledim.write(pointerz2_re, bytesz2_re);\r\n\t\tconst char* pointerz2_im = reinterpret_cast(&fz2_ims[0]);\r\n\t\tstd::size_t bytesz2_im = fz2_ims.size() * sizeof(fz2_ims[0]);\r\n\t\toutfiledim.write(pointerz2_im, bytesz2_im);\r\n\r\n\t}\r\n\r\n\t// Close the output files\r\n\toutfile.close();\r\n\toutfiledim.close();\r\n\r\n\t// Get the date and execution time\r\n\tauto end = std::chrono::high_resolution_clock::now();\r\n\tauto date_time3 = std::chrono::system_clock::now();\r\n\tauto elapsed_seconds = std::chrono::duration_cast(end - start);\r\n\tlong long mseconds = elapsed_seconds.count();\r\n\tlong long seconds, hours, minutes;\r\n\tstd::tie(mseconds, seconds, minutes, hours) = ms_to_time(mseconds);\r\n\tstd::time_t end_time = std::chrono::system_clock::to_time_t(date_time3);\r\n\tchar str_time[26];\r\n\tctime_s(str_time, sizeof str_time, &end_time);\r\n\r\n\tstd::cout << \"Program finnished after \";\r\n\ttime_print(mseconds, seconds, minutes, hours);\r\n\tstd::cout << std::endl;\r\n\tstd::cout << \"Output data saved to binary files: data.bin and dim_data.bin\" << std::endl;\r\n\r\n\treturn 0;\r\n}", "meta": {"hexsha": "c539f7d7be8dd983f59d0e034aa4e3c9e49afafb", "size": 61312, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "AE_LE_master.cpp", "max_stars_repo_name": "eriktoller/AE_LE_crack", "max_stars_repo_head_hexsha": "e8d8c067da2fd1d184e8926b8075fe9f58e3250e", "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": "AE_LE_master.cpp", "max_issues_repo_name": "eriktoller/AE_LE_crack", "max_issues_repo_head_hexsha": "e8d8c067da2fd1d184e8926b8075fe9f58e3250e", "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": "AE_LE_master.cpp", "max_forks_repo_name": "eriktoller/AE_LE_crack", "max_forks_repo_head_hexsha": "e8d8c067da2fd1d184e8926b8075fe9f58e3250e", "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.2142857143, "max_line_length": 247, "alphanum_fraction": 0.5420472338, "num_tokens": 20282, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833945721304, "lm_q2_score": 0.6442251133170356, "lm_q1q2_score": 0.4990060751417248}} {"text": "#include \n#include \n#include \"geometrycentral/surface/manifold_surface_mesh.h\"\n#include \"geometrycentral/utilities/mesh_data.h\"\n#include \"geometrycentral/surface/edge_length_geometry.h\"\n#include \"geometrycentral/surface/heat_method_distance.h\"\n#include \n#include \n#include \n\nusing namespace geometrycentral;\nusing namespace geometrycentral::surface;\ntypedef int iptr_t;\ntypedef int dptr_t;\n\n// mesh data\nstatic Eigen::MatrixX3i faces;\nstatic Eigen::MatrixX3d edges;\nstatic EdgeData edgeLengths;\n\n// mesh containers\nstatic std::unique_ptr mesh;\nstatic std::unique_ptr geometry;\n\n// the Heat Method solver\nstatic std::unique_ptr heatSolver;\n\n// the output vertex data\nstatic VertexData distToSource;\n\n// parameters\nstatic double timeStep = 1.0;\nstatic bool robust = false;\nstatic bool verbose = true;\n\nstd::string getExceptionMessage(intptr_t exceptionPtr) {\n return std::string(reinterpret_cast(exceptionPtr)->what());\n}\n\nEMSCRIPTEN_BINDINGS(Bindings) {\n emscripten::function(\"getExceptionMessage\", &getExceptionMessage);\n};\n\nextern \"C\" {\n\n EMSCRIPTEN_KEEPALIVE\n iptr_t allocate_faces(size_t num_faces){\n faces.resize(num_faces, 3);\n edges.resize(num_faces, 3);\n return reinterpret_cast(&faces(0, 0));\n }\n EMSCRIPTEN_KEEPALIVE\n void set_face(size_t f, size_t idx0, size_t idx1, size_t idx2){\n faces(f, 0) = idx0;\n faces(f, 1) = idx1;\n faces(f, 2) = idx2;\n }\n EMSCRIPTEN_KEEPALIVE\n void set_face_edges(size_t f, double e0, double e1, double e2){\n edges(f, 0) = e0;\n edges(f, 1) = e1;\n edges(f, 2) = e2;\n }\n EMSCRIPTEN_KEEPALIVE\n void print_faces(){\n std::cout << \"Faces:\\n\" << faces << \"\\n\";\n }\n EMSCRIPTEN_KEEPALIVE\n dptr_t get_edge_ptr(){\n return reinterpret_cast(&edges(0, 0));\n }\n EMSCRIPTEN_KEEPALIVE\n void print_edges(){\n std::cout << \"Edges:\\n\" << edges << \"\\n\";\n }\n\n EMSCRIPTEN_KEEPALIVE\n iptr_t allocate_edges(size_t num_edges){\n edges.resize(num_edges, 3);\n return reinterpret_cast(&edges(0, 0));\n }\n\n EMSCRIPTEN_KEEPALIVE\n void set_verbose(bool v = true){\n verbose = v;\n }\n EMSCRIPTEN_KEEPALIVE\n void set_quiet(){\n set_verbose(false);\n }\n EMSCRIPTEN_KEEPALIVE\n void set_time_step(double step){\n timeStep = step;\n }\n EMSCRIPTEN_KEEPALIVE\n void set_robust(bool flag){\n robust = flag;\n }\n\n EMSCRIPTEN_KEEPALIVE\n void create_surface_mesh(){\n // create underlying mesh topology\n mesh.reset(new ManifoldSurfaceMesh(faces));\n mesh->compress();\n if(verbose)\n mesh->printStatistics();\n }\n\n EMSCRIPTEN_KEEPALIVE \n void precompute(){\n\n // create implicit geometry using edge lengths and mesh\n edgeLengths = EdgeData(*mesh);\n for(size_t i = 0; i < faces.rows(); ++i){\n if(verbose)\n printf(\"Setting lengths of face #%zu\\n\", i);\n Face f = mesh->face(i);\n if(!f.isTriangle()){\n printf(\"Face is not a triangle\\n\");\n return;\n }\n Halfedge he = f.halfedge(); edgeLengths[he.edge()] = edges(i, 0);\n he = he.next(); edgeLengths[he.edge()] = edges(i, 1);\n he = he.next(); edgeLengths[he.edge()] = edges(i, 2);\n }\n if(verbose){\n std::cout << \"Edges:\\n\" << edgeLengths.raw() << \"\\n\";\n for(Edge e : mesh->edges()){\n printf(\"Edge #%zu = %g\\n\", e.getIndex(), edgeLengths[e]);\n }\n }\n geometry.reset(new EdgeLengthGeometry(*mesh, edgeLengths));\n\n // create heat method distance solver (precomputation happens here)\n heatSolver.reset(new HeatMethodDistanceSolver(*geometry, timeStep, robust));\n }\n\n EMSCRIPTEN_KEEPALIVE\n dptr_t compute_from_source(size_t srcIndex){\n const Vertex v = mesh->vertex(srcIndex);\n distToSource = heatSolver->computeDistance(v);\n\n if(verbose)\n printf(\"Returning result pointer\\n\");\n\n Eigen::VectorXd &mat = distToSource.raw();\n double* ptr = &mat(0, 0);\n return reinterpret_cast(ptr);\n }\n\n}", "meta": {"hexsha": "3ed87792df857a53153bcfa7325d15f40e6d2b17", "size": 4047, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/geodesic-dist/gdist.cpp", "max_stars_repo_name": "xionluhnis/knitsketching", "max_stars_repo_head_hexsha": "3e13670caa911b6d5e3c9c036c0ee15184e7d138", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2021-08-16T05:19:59.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-09T17:46:12.000Z", "max_issues_repo_path": "libs/geodesic-dist/gdist.cpp", "max_issues_repo_name": "xionluhnis/knitsketching", "max_issues_repo_head_hexsha": "3e13670caa911b6d5e3c9c036c0ee15184e7d138", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2021-08-25T07:11:39.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-19T09:16:05.000Z", "max_forks_repo_path": "libs/geodesic-dist/gdist.cpp", "max_forks_repo_name": "xionluhnis/knitsketching", "max_forks_repo_head_hexsha": "3e13670caa911b6d5e3c9c036c0ee15184e7d138", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-08-12T11:49:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-19T07:51:53.000Z", "avg_line_length": 26.8013245033, "max_line_length": 81, "alphanum_fraction": 0.6849518162, "num_tokens": 1113, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833945721303, "lm_q2_score": 0.6442251064863697, "lm_q1q2_score": 0.49900606985080437}} {"text": "#include \n#include \n#include \n\n#include \n\ntypedef CGAL::Exact_predicates_exact_constructions_kernel K;\ntypedef K::Point_2 Point;\ntypedef K::Segment_2 Segment;\n\ntypedef CGAL::Creator_uniform_2 Pt_creator;\ntypedef CGAL::Random_points_on_segment_2 P1;\ntypedef CGAL::Random_points_on_circle_2 P2;\ntypedef CGAL::Creator_uniform_2< Point, Segment> Seg_creator;\ntypedef CGAL::Join_input_iterator_2< P1, P2, Seg_creator> Seg_iterator;\n\nstruct Intersector{\n typedef CGAL::cpp11::result_of::type result_type;\n const Segment& s;\n K::Intersect_2 intersect;\n\n Intersector(const Segment& seg): s(seg) {}\n\n result_type\n operator() ( const Segment& other) const\n {\n return intersect(s, other);\n }\n};\n\nint main()\n{\n std::vector input;\n\n // Prepare point generator for the horizontal segment, length 200.\n P1 p1( Point(-100,0), Point(100,0));\n\n // Prepare point generator for random points on circle, radius 250.\n P2 p2( 250);\n\n // Create segments.\n Seg_iterator g( p1, p2);\n std::copy_n( g, 200, std::back_inserter(input));\n\n\n // splitting results with Dispatch_output_iterator\n std::vector points;\n std::vector segments;\n\n typedef CGAL::Dispatch_output_iterator<\n std::tuple, std::tuple< std::back_insert_iterator >,\n std::back_insert_iterator > > >\n Dispatcher;\n\n Dispatcher disp = CGAL::dispatch_output( std::back_inserter(points),\n std::back_inserter(segments) );\n\n // intersects the first segment of input with all other segments\n // The resulting points or segments are written in the vectors with the same names\n std::transform( input.begin(), input.end(), disp,\n Intersector(input.front()) );\n\n\n std::cout << \"Point intersections: \" << points.size() << std::endl;\n std::cout << \"Segment intersections: \" << segments.size() << std::endl;\n\n\n return 0;\n}\n", "meta": {"hexsha": "283fd5b9aada7804969b838c9f505e33ca69dc2e", "size": 2252, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Kernel_23/examples/Kernel_23/intersections.cpp", "max_stars_repo_name": "gaschler/cgal", "max_stars_repo_head_hexsha": "d1fe2afa18da5524db6d4946f42ca4b8d00e0bda", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2020-12-12T09:30:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-04T05:00:23.000Z", "max_issues_repo_path": "Kernel_23/examples/Kernel_23/intersections.cpp", "max_issues_repo_name": "gaschler/cgal", "max_issues_repo_head_hexsha": "d1fe2afa18da5524db6d4946f42ca4b8d00e0bda", "max_issues_repo_licenses": ["CC0-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": "Kernel_23/examples/Kernel_23/intersections.cpp", "max_forks_repo_name": "gaschler/cgal", "max_forks_repo_head_hexsha": "d1fe2afa18da5524db6d4946f42ca4b8d00e0bda", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-12-02T11:11:36.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-02T11:11:36.000Z", "avg_line_length": 32.1714285714, "max_line_length": 99, "alphanum_fraction": 0.6758436945, "num_tokens": 552, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833841649233, "lm_q2_score": 0.6442250928250375, "lm_q1q2_score": 0.4990060525643794}} {"text": "// Copyright 2017 Rainer Gemulla\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/** \\file\n *\n * Illustrates matrix factorization with SGD. We first creates factors and then a data matrix\n * from these factors. THis process ensures that we know the best factorization of the input.\n * We then try to reconstruct the factors using SGD.\n */\n#include \n\n#include \n#include \n\n#include \n#include \n\n#include \n\nusing namespace std;\nusing namespace mf;\nusing namespace rg;\nusing namespace boost::numeric::ublas;\n\nlog4cxx::LoggerPtr logger(log4cxx::Logger::getLogger(\"main\"));\n\nint main(int argc, char* argv[]) {\n#ifndef NDEBUG\n\tLOG4CXX_WARN(logger, \"Warning: Debug mode activated (runtimes may be slow).\");\n#endif\n\n\t// parameters for the factorization\n\tmf_size_type size1 = 10000;\n\tmf_size_type size2 = 10000;\n\tmf_size_type nnz = 1000000;\n\tdouble sigma = 1; // standard deviation\n\tdouble lambda = 1/sigma/sigma;\n\tmf_size_type r = 10;\n\n\t// parameters for SGD\n\tdouble eps0 = 0.1;\n\tunsigned epochs = 20;\n\tSgdOrder order = SGD_ORDER_WOR;\n\ttypedef UpdateTruncate Update;\n\ttypedef RegularizeL2 Regularize;\n\ttypedef SumLoss Loss;\n\ttypedef NzslLoss TestLoss;\n\tUpdate update = Update(UpdateNzsl(), -10*sigma, 10*sigma); // truncate for numerical stability\n\tRegularize regularize = Regularize(lambda);\n\tLoss loss((NzslLoss()), L2Loss(lambda));\n\tTestLoss testLoss;\n\tmf_size_type testNnz = nnz/100;\n\tBalanceType balanceType = BALANCE_NONE;\n\tBalanceMethod balanceMethod = BALANCE_SIMPLE;\n\n\n\t// generate original factors by sampling from a normal(0,sigma) distribution\n\tRandom32 random; // note: this takes a default seed (not randomized!)\n\tDenseMatrix wIn(size1, r);\n\tDenseMatrixCM hIn(r, size2);\n\tgenerateRandom(wIn, random, boost::normal_distribution<>(0, sigma));\n\tgenerateRandom(hIn, random, boost::normal_distribution<>(0, sigma));\n\n\t// generate a sparse matrix by selecting random entries from the generated factors\n\t// and add small Gaussian noise\n\tSparseMatrix v;\n\tgenerateRandom(v, nnz, wIn, hIn, random);\n\taddRandom(v, random, boost::normal_distribution<>(0, 0.1));\n\tLOG4CXX_INFO(logger, \"Data matrix: \"\n\t\t<< v.size1() << \" x \" << v.size2() << \", \" << v.nnz() << \" nonzeros\");\n\tLOG4CXX_INFO(logger, \"Loss with original factors: \" << loss((FactorizationData<>(v, wIn, hIn))));\n\n\t// create a test matrix (without noise)\n\tSparseMatrix vTest;\n\tgenerateRandom(vTest, testNnz, wIn, hIn, random);\n\tLOG4CXX_INFO(logger, \"Test matrix: \"\n\t\t<< v.size1() << \" x \" << v.size2() << \", \" << vTest.nnz() << \" nonzeros\");\n\n\t// take a small sample and remove empty rows/columns\n\tProjectedSparseMatrix Vsample;\n\tprojectRandomSubmatrix(random, v, Vsample, v.size1()/5, v.size2()/5);\n\tprojectFrequent(Vsample, 0);\n\tLOG4CXX_INFO(logger, \"Sample matrix: \"\n\t\t<< Vsample.data.size1() << \" x \" << Vsample.data.size2()\n\t\t<< \", \" << Vsample.data.nnz() << \" nonzeros\");\n\n\t// generate initial factors by sampling from a uniform[-0.5,0.5] distribution\n\tDenseMatrix w(size1, r);\n\tDenseMatrixCM h(r, size2);\n\tgenerateRandom(w, random, boost::uniform_real<>(-0.5, 0.5));\n\tgenerateRandom(h, random, boost::uniform_real<>(-0.5, 0.5));\n\n\t// initialize the SGD\n\tTimer t;\n\tSgdRunner sgdRunner(random);\n\tSgdJob job(v, w, h, update, regularize, order);\n\tFactorizationData<> testJob(vTest, w, h);\n\tDecayAuto decay(job, loss, Vsample, eps0, 4);\n\tTrace trace;\n\n\t// print the test loss\n\tLOG4CXX_INFO(logger, \"Initial test loss: \"\n\t\t\t<< testLoss(FactorizationData<>(vTest,w,h)));\n\n\t// run SGD to try to reconstruct the original factors\n\tt.start();\n\tsgdRunner.run(job, loss, epochs, decay, trace, balanceType, balanceMethod, &testJob, &testLoss);\n\tt.stop();\n\tLOG4CXX_INFO(logger, \"Total time: \" << t);\n\n\t// print the test loss\n\tLOG4CXX_INFO(logger, \"Final test loss: \"\n\t\t\t<< testLoss(FactorizationData<>(vTest,w,h)));\n\n\t// write trace to an R file\n\tLOG4CXX_INFO(logger, \"Writing trace to \" << \"/tmp/sgd-trace.R\");\n\ttrace.toRfile(\"/tmp/sgd-trace.R\", \"sgd\");\n\n\treturn 0;\n}\n\n", "meta": {"hexsha": "1e83a71f1d64e0574831584f1e27a5b764e81212", "size": 4646, "ext": "cc", "lang": "C++", "max_stars_repo_path": "examples/mf/sgd.cc", "max_stars_repo_name": "Hui-Li/DSGDPP", "max_stars_repo_head_hexsha": "0ce5b115bfbed81cee1c39fbfa4a8f67a5e1b72e", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2017-01-10T11:39:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-02T23:03:55.000Z", "max_issues_repo_path": "examples/mf/sgd.cc", "max_issues_repo_name": "Hui-Li/DSGDPP", "max_issues_repo_head_hexsha": "0ce5b115bfbed81cee1c39fbfa4a8f67a5e1b72e", "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/mf/sgd.cc", "max_forks_repo_name": "Hui-Li/DSGDPP", "max_forks_repo_head_hexsha": "0ce5b115bfbed81cee1c39fbfa4a8f67a5e1b72e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 6.0, "max_forks_repo_forks_event_min_datetime": "2017-10-27T18:40:47.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-05T15:10:56.000Z", "avg_line_length": 35.196969697, "max_line_length": 98, "alphanum_fraction": 0.713086526, "num_tokens": 1299, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7310585669110203, "lm_q2_score": 0.6825737279551494, "lm_q1q2_score": 0.49900137137000417}} {"text": "/*******************************************************************************\n * Copyright (c) 2018-, UT-Battelle, LLC.\n * All rights reserved. This program and the accompanying materials\n * are made available under the terms of the MIT License \n * which accompanies this distribution. \n *\n * Contributors:\n * Alexander J. McCaskey - initial API and implementation\n * Thien Nguyen - implementation\n *******************************************************************************/\n#include \"qsim_utils.hpp\"\n#include \n#include \n#include \n#include \nnamespace qcor {\nnamespace QuaSiMo {\nstd::shared_ptr\ngetEvaluator(Operator *observable, const HeterogeneousMap ¶ms) {\n // If an evaluator was provided explicitly:\n if (params.pointerLikeExists(\"evaluator\")) {\n return xacc::as_shared_ptr(\n params.getPointerLike(\"evaluator\"));\n }\n\n // Cost Evaluator was provided by name:\n if (params.stringExists(\"evaluator\")) {\n return getObjEvaluator(observable, params.getString(\"evaluator\"));\n }\n\n // No specific evaluator/evaluation method was requested,\n // use the default one (partial tomography based).\n return getObjEvaluator(observable);\n}\n\nPronyResult pronyFit(const std::vector> &in_signal) {\n assert(!in_signal.empty());\n\n // Returns the Hankel matrix constructed from the first column c, and\n // (optionally) the last row r.\n auto hankelMat =\n [](const std::vector> &c,\n const std::vector> &r) -> Eigen::MatrixXcd {\n Eigen::MatrixXcd result = Eigen::MatrixXcd::Zero(c.size(), r.size());\n const auto m = c.size();\n for (int i = 0; i < result.rows(); ++i) {\n for (int j = 0; j < result.cols(); ++j) {\n // H(i,j) = c(i+j), i+j < m;\n if (i + j < m) {\n result(i, j) = c[i + j];\n } else {\n // H(i,j) = r(i+j+1-m), otherwise\n result(i, j) = r[i + j + 1 - m];\n }\n }\n }\n\n return result;\n };\n\n // Pythonic vector slice:\n auto vectorSlice = [](const std::vector> &in_vec,\n int in_start, int in_end) {\n std::vector> result;\n auto startIter = in_vec.begin() + in_start;\n auto endIter =\n in_end > 0 ? in_vec.begin() + in_end : (in_vec.end() + in_end);\n result.assign(startIter, endIter);\n return result;\n };\n\n const size_t num_freqs = in_signal.size() / 2;\n auto hankel0 = hankelMat(vectorSlice(in_signal, 0, num_freqs),\n vectorSlice(in_signal, num_freqs - 1, -1));\n auto hankel1 = hankelMat(vectorSlice(in_signal, 1, num_freqs + 1),\n vectorSlice(in_signal, num_freqs, 0));\n // std::cout << \"Hankel Matrix 0: \\n\" << hankel0 << \"\\n\";\n // std::cout << \"Hankel Matrix 1: \\n\" << hankel1 << \"\\n\";\n\n hankel0.transposeInPlace();\n hankel1.transposeInPlace();\n Eigen::MatrixXcd shift_matrix =\n Eigen::MatrixXcd::Zero(hankel0.cols(), hankel1.cols());\n\n for (size_t i = 0; i < hankel1.cols(); ++i) {\n Eigen::VectorXcd shift_matrix_col =\n hankel0.fullPivHouseholderQr().solve(hankel1.col(i));\n shift_matrix.col(i) = shift_matrix_col;\n }\n // std::cout << \"Shift matrix: \\n\" << shift_matrix << \"\\n\";\n\n shift_matrix.transposeInPlace();\n Eigen::ComplexEigenSolver s(shift_matrix);\n auto phases = s.eigenvalues();\n Eigen::MatrixXcd generation_matrix =\n Eigen::MatrixXcd::Zero(in_signal.size(), phases.size());\n for (int i = 0; i < generation_matrix.rows(); ++i) {\n for (int j = 0; j < generation_matrix.cols(); ++j) {\n generation_matrix(i, j) = std::pow(phases[j], i);\n }\n }\n\n auto signalData = in_signal;\n Eigen::VectorXcd signal =\n Eigen::Map(signalData.data(), signalData.size());\n Eigen::VectorXcd amplitudes =\n generation_matrix.fullPivHouseholderQr().solve(signal);\n assert(phases.size() == amplitudes.size());\n // std::cout << \"Amplitude:\\n\" << amplitudes << \"\\n\";\n // std::cout << \"Phases:\\n\" << phases << \"\\n\";\n PronyResult finalResult;\n for (size_t i = 0; i < phases.size(); ++i) {\n finalResult.emplace_back(std::make_pair(amplitudes(i), phases(i)));\n }\n\n // Sort by amplitude:\n std::sort(finalResult.begin(), finalResult.end(),\n [](const auto &a, const auto &b) {\n return std::abs(a.first) < std::abs(b.first);\n });\n\n return finalResult;\n}\n} // namespace QuaSiMo\n} // namespace qcor", "meta": {"hexsha": "b12f110f11dea3cc4c076fa79c01179b893b8405", "size": 4561, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "lib/quasimo/impls/utils/qsim_utils.cpp", "max_stars_repo_name": "vetter/qcor", "max_stars_repo_head_hexsha": "6f86835737277a26071593bb10dd8627c29d74a3", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 59.0, "max_stars_repo_stars_event_min_datetime": "2019-08-22T18:40:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T04:12:42.000Z", "max_issues_repo_path": "lib/quasimo/impls/utils/qsim_utils.cpp", "max_issues_repo_name": "vetter/qcor", "max_issues_repo_head_hexsha": "6f86835737277a26071593bb10dd8627c29d74a3", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 137.0, "max_issues_repo_issues_event_min_datetime": "2019-09-13T15:50:18.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-06T14:19:46.000Z", "max_forks_repo_path": "lib/quasimo/impls/utils/qsim_utils.cpp", "max_forks_repo_name": "vetter/qcor", "max_forks_repo_head_hexsha": "6f86835737277a26071593bb10dd8627c29d74a3", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 26.0, "max_forks_repo_forks_event_min_datetime": "2019-07-08T17:30:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-03T16:24:12.000Z", "avg_line_length": 36.488, "max_line_length": 81, "alphanum_fraction": 0.6103924578, "num_tokens": 1229, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256472515683, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.4989219441107211}} {"text": "#include \"TriangleMuscleConstraint.h\"\n#include \n#include \n#include \n#include \n\nusing namespace FEM;\nTriangleMuscleConstraint::\nTriangleMuscleConstraint(double stiffness,const Eigen::Vector2d& fiber_direction,int i0,int i1,int i2,double area,const Eigen::Matrix2d& invDm)\n\t:Constraint(stiffness),mFiberDirection(fiber_direction),\n\tmi0(i0),mi1(i1),mi2(i2),mArea(area),mInvDm(invDm),mActivationLevel(0.0)\n{\n\n}\nint\nTriangleMuscleConstraint::\nGetDof()\n{\n\treturn 1;\n}\n\nvoid\nTriangleMuscleConstraint::\nEvaluateJMatrix(int index, std::vector>& J_triplets)\n{\n\tEigen::MatrixXd Ai(3,9);\n\n\tEigen::Vector2d v = mInvDm*mFiberDirection;\n\n\tAi<<\n\t\t-v[0]-v[1],0,0,v[0],0,0,v[1],0,0,\n\t\t0,-v[0]-v[1],0,0,v[0],0,0,v[1],0,\n\t\t0,0,-v[0]-v[1],0,0,v[0],0,0,v[1];\n\n\tEigen::MatrixXd MuAiT = mStiffness*mArea*Ai.transpose();\n\n\tint idx[3] = {mi0,mi1,mi2};\n\n\tfor(int i=0;i<3;i++)\n\t{\n\t\tJ_triplets.push_back(Eigen::Triplet(3*idx[i]+0, 3*(index)+0, MuAiT(3*i+0,0)));\n\t\tJ_triplets.push_back(Eigen::Triplet(3*idx[i]+0, 3*(index)+1, MuAiT(3*i+0,1)));\n\t\tJ_triplets.push_back(Eigen::Triplet(3*idx[i]+0, 3*(index)+2, MuAiT(3*i+0,2)));\n\t\tJ_triplets.push_back(Eigen::Triplet(3*idx[i]+1, 3*(index)+0, MuAiT(3*i+1,0)));\n\t\tJ_triplets.push_back(Eigen::Triplet(3*idx[i]+1, 3*(index)+1, MuAiT(3*i+1,1)));\n\t\tJ_triplets.push_back(Eigen::Triplet(3*idx[i]+1, 3*(index)+2, MuAiT(3*i+1,2)));\n\t\tJ_triplets.push_back(Eigen::Triplet(3*idx[i]+2, 3*(index)+0, MuAiT(3*i+2,0)));\n\t\tJ_triplets.push_back(Eigen::Triplet(3*idx[i]+2, 3*(index)+1, MuAiT(3*i+2,1)));\n\t\tJ_triplets.push_back(Eigen::Triplet(3*idx[i]+2, 3*(index)+2, MuAiT(3*i+2,2)));\n\t}\n}\nvoid\nTriangleMuscleConstraint::\nEvaluateLMatrix(std::vector>& L_triplets)\n{\n\tEigen::MatrixXd Ai(3,9);\n\n\tEigen::Vector2d v = mInvDm*mFiberDirection;\n\tAi<<\n\t\t-v[0]-v[1],0,0,v[0],0,0,v[1],0,0,\n\t\t0,-v[0]-v[1],0,0,v[0],0,0,v[1],0,\n\t\t0,0,-v[0]-v[1],0,0,v[0],0,0,v[1];\n\n\tEigen::MatrixXd MuAiTAi = mStiffness*mArea*((Ai.transpose())*Ai);\n\n\tint idx[3] = {mi0,mi1,mi2};\n\tfor(int i =0;i<3;i++)\n\t{\n\t\tfor(int j=0;j<3;j++)\n\t\t{\n\t\t\tL_triplets.push_back(Eigen::Triplet(3*idx[i]+0, 3*idx[j]+0, MuAiTAi(3*i+0, 3*j+0)));\n\t\t\tL_triplets.push_back(Eigen::Triplet(3*idx[i]+0, 3*idx[j]+1, MuAiTAi(3*i+0, 3*j+1)));\n\t\t\tL_triplets.push_back(Eigen::Triplet(3*idx[i]+0, 3*idx[j]+2, MuAiTAi(3*i+0, 3*j+2)));\n\t\t\tL_triplets.push_back(Eigen::Triplet(3*idx[i]+1, 3*idx[j]+0, MuAiTAi(3*i+1, 3*j+0)));\n\t\t\tL_triplets.push_back(Eigen::Triplet(3*idx[i]+1, 3*idx[j]+1, MuAiTAi(3*i+1, 3*j+1)));\n\t\t\tL_triplets.push_back(Eigen::Triplet(3*idx[i]+1, 3*idx[j]+2, MuAiTAi(3*i+1, 3*j+2)));\n\t\t\tL_triplets.push_back(Eigen::Triplet(3*idx[i]+2, 3*idx[j]+0, MuAiTAi(3*i+2, 3*j+0)));\n\t\t\tL_triplets.push_back(Eigen::Triplet(3*idx[i]+2, 3*idx[j]+1, MuAiTAi(3*i+2, 3*j+1)));\n\t\t\tL_triplets.push_back(Eigen::Triplet(3*idx[i]+2, 3*idx[j]+2, MuAiTAi(3*i+2, 3*j+2)));\n\t\t}\n\t}\n}\nvoid\nTriangleMuscleConstraint::\nEvaluateDVector(const Eigen::VectorXd& x)\n{\n\tEigen::Vector3d x0(x.segment<3>(mi0*3));\n\n\tEigen::Matrix32d Ds, P;\n\tDs.col(0) = x.segment<3>(mi1*3) - x0;\n\tDs.col(1) = x.segment<3>(mi2*3) - x0;\n\n\tP.col(0) = Ds.col(0).normalized();\n\tP.col(1) = (Ds.col(1)-Ds.col(1).dot(P.col(0))*P.col(0)).normalized();\n\n\tEigen::Matrix2d F = P.transpose()*Ds*mInvDm;\n\n\tmd = (1.0-mActivationLevel)*P*F*mFiberDirection;\t\n}\nvoid\nTriangleMuscleConstraint::\nGetDVector(int& index,Eigen::VectorXd& d)\n{\n\td.segment<3>(3*(index)) = md;\n\tindex++;\n}", "meta": {"hexsha": "7fd2ebd44b5226fd0812838c916d6fb4633def34", "size": 3590, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "sim/fem/Constraint/TriangleMuscleConstraint.cpp", "max_stars_repo_name": "liusida/SoftCon", "max_stars_repo_head_hexsha": "39adcb1e2364dd7583b01966af7038d77977e083", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 140.0, "max_stars_repo_stars_event_min_datetime": "2019-09-05T03:24:08.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-18T13:44:48.000Z", "max_issues_repo_path": "sim/fem/Constraint/TriangleMuscleConstraint.cpp", "max_issues_repo_name": "liusida/SoftCon", "max_issues_repo_head_hexsha": "39adcb1e2364dd7583b01966af7038d77977e083", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-03-15T14:23:02.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-15T14:23:02.000Z", "max_forks_repo_path": "sim/fem/Constraint/TriangleMuscleConstraint.cpp", "max_forks_repo_name": "liusida/SoftCon", "max_forks_repo_head_hexsha": "39adcb1e2364dd7583b01966af7038d77977e083", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 23.0, "max_forks_repo_forks_event_min_datetime": "2019-09-08T02:51:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-17T12:49:05.000Z", "avg_line_length": 33.8679245283, "max_line_length": 143, "alphanum_fraction": 0.6601671309, "num_tokens": 1493, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256393148981, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.49892193940692176}} {"text": "#include \n#include \n\n#include \n\n#define PI 3.1415926535897932384\n\ntypedef int int_t;\n\n//#include \"Tile3D.h\"\nKOKKOS_FUNCTION double left_flux(double left, double self, double cfl)\n{\n return -cfl * left + cfl * self;\n}\n\nKOKKOS_FUNCTION double right_flux(double self, double right, double cfl)\n{\n return -cfl * right + cfl * self;\n}\n\nKOKKOS_FUNCTION double stencil6p(double self, double xm, double xp, double ym,\n double yp, double zm, double zp, double cfl)\n{\n return (1.0 - 6.0 * cfl) * self + cfl * (xm + xp + ym + yp + zm + zp);\n}\n\nint main(int argc, char* argv[])\n{\n double cfl = 0.1; // must be less than 1/6\n\n namespace bpo = boost::program_options;\n bpo::options_description desc(\"ABFT3D\");\n\n desc.add_options()(\n \"xsize\", bpo::value()->default_value(98), \"X Dimension\");\n desc.add_options()(\n \"ysize\", bpo::value()->default_value(98), \"Y Dimension\");\n desc.add_options()(\n \"zsize\", bpo::value()->default_value(98), \"Z Dimension\");\n\n bpo::variables_map vm;\n\n // Setup commandline arguments\n bpo::store(bpo::parse_command_line(argc, argv, desc), vm);\n bpo::notify(vm);\n\n int xsize = vm[\"xsize\"].as();\n int ysize = vm[\"ysize\"].as();\n int zsize = vm[\"zsize\"].as();\n\n bool do_check_sum = true;\n\n Kokkos::initialize(argc, argv);\n {\n using range_policy = Kokkos::RangePolicy<>;\n\n Kokkos::View stencil_0(\n \"data1\", xsize + 2, ysize + 2, zsize + 2);\n Kokkos::View stencil_1(\n \"data2\", xsize + 2, ysize + 2, zsize + 2);\n\n // Soft copy\n auto stencil_old = stencil_0;\n auto stencil_new = stencil_1;\n auto stencil_tmp = stencil_new;\n Kokkos::View> checksum(\n \"checksum\", 1);\n\n Kokkos::View hchecksum(\n \"h_checksum\", 1);\n hchecksum[0] = 0.;\n\n Kokkos::deep_copy(checksum, hchecksum);\n\n // Initialize stencil\n Kokkos::parallel_for(\n \"init\", range_policy(0, ysize + 2), KOKKOS_LAMBDA(int j) {\n for (int k = 0; k < zsize + 2; ++k)\n {\n for (int i = 0; i < xsize + 2; ++i)\n {\n stencil_old(i, j, k) = std::sin(1.0 * PI * (double) i /\n (double) (xsize + 1)); //*\n stencil_new(i, j, k) = stencil_old(i, j, k);\n }\n }\n });\n Kokkos::fence();\n\n Kokkos::Timer timer;\n\n //\n // How to catch the error ... order matters. where does the error come from?\n // Physical location could matter (plus interaction with OS)\n //\n\n // Original checksum\n if (do_check_sum)\n {\n Kokkos::parallel_for(\n \"init_checksum\", range_policy(1, xsize + 1),\n KOKKOS_LAMBDA(int i) {\n for (int j = 1; j <= ysize; ++j)\n {\n for (int k = 1; k <= zsize; ++k)\n {\n checksum[0] += stencil_old(i, j, k);\n }\n }\n });\n Kokkos::fence();\n }\n\n Kokkos::deep_copy(hchecksum, checksum);\n\n std::cout << \"Initial Checksum \" << std::scientific << hchecksum[0]\n << std::endl;\n\n double chk_ = 0;\n for (int its = 0; its < 10; ++its)\n {\n if (do_check_sum)\n {\n // Deduct the checksum from the boundary\n Kokkos::parallel_for(\n \"first_loop\", range_policy(1, zsize + 1),\n KOKKOS_LAMBDA(int k) {\n for (int j = 1; j <= ysize; ++j)\n {\n checksum[0] -= left_flux(stencil_old(0, j, k),\n stencil_old(1, j, k), cfl) +\n right_flux(stencil_old(xsize, j, k),\n stencil_old(xsize + 1, j, k), cfl);\n }\n });\n Kokkos::fence();\n\n Kokkos::parallel_for(\n \"second_loop\", range_policy(1, zsize + 1),\n KOKKOS_LAMBDA(int k) {\n for (int i = 1; i <= xsize; ++i)\n {\n checksum[0] -= left_flux(stencil_old(i, 0, k),\n stencil_old(i, 1, k), cfl) +\n right_flux(stencil_old(i, ysize, k),\n stencil_old(i, ysize + 1, k), cfl);\n }\n });\n Kokkos::fence();\n\n Kokkos::parallel_for(\n \"third_loop\", range_policy(1, ysize + 1),\n KOKKOS_LAMBDA(int j) {\n for (int i = 1; i <= xsize; ++i)\n {\n checksum[0] -= left_flux(stencil_old(i, j, 0),\n stencil_old(i, j, 1), cfl) +\n right_flux(stencil_old(i, j, zsize),\n stencil_old(i, j, zsize + 1), cfl);\n }\n });\n Kokkos::fence();\n }\n\n // Apply stencil\n // Replace the loops by parallel for\n //\n Kokkos::parallel_reduce(\n \"stencil_op\", range_policy(1, xsize + 1),\n KOKKOS_LAMBDA(int i, double& chk_) {\n for (int j = 1; j <= ysize; ++j)\n {\n for (int k = 1; k <= zsize; ++k)\n {\n //std::cout << \"Old \" << i << \" \" << j << \" \" << k << \": \" << stencil_old(i,j,k) << std::endl;\n stencil_new(i, j, k) = stencil6p(\n stencil_old(i, j, k), stencil_old(i - 1, j, k),\n stencil_old(i + 1, j, k),\n stencil_old(i, j - 1, k),\n stencil_old(i, j + 1, k),\n stencil_old(i, j, k - 1),\n stencil_old(i, j, k + 1), cfl);\n\n chk_ += stencil_new(i, j, k);\n }\n }\n },\n chk_);\n Kokkos::fence();\n\n // chk_ = 0;\n\n if (do_check_sum)\n {\n Kokkos::deep_copy(hchecksum, checksum);\n\n // Testing the checksum\n auto error = std::abs((chk_ - hchecksum[0]));\n\n std::cout << \"New Checksum \" << std::scientific << chk_\n << \" and analytical checksum \" << hchecksum[0]\n << \" with Error: \" << error << std::endl;\n\n if (error > 1e-2)\n {\n std::cout << \"Failed \" << error << std::endl;\n }\n\n // Alternate stencil assignment\n if (its % 2 == 0)\n {\n stencil_old = stencil_1;\n stencil_new = stencil_0;\n }\n else\n {\n stencil_old = stencil_0;\n stencil_new = stencil_1;\n }\n\n chk_ = 0.;\n }\n }\n\n double time_taken = timer.seconds();\n\n std::cout << \"Executed in: \" << time_taken << std::endl;\n }\n\n Kokkos::finalize();\n return 0;\n}", "meta": {"hexsha": "0fd7564e472a5692ca45fa1fb70a865c71d1c345", "size": 7827, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "applications/non-resilient/ABFT3D.cpp", "max_stars_repo_name": "NK-Nikunj/Kokkos-Resilient-Spaces", "max_stars_repo_head_hexsha": "7203d40747d1961286cb4f9ca872354f395ac601", "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": "applications/non-resilient/ABFT3D.cpp", "max_issues_repo_name": "NK-Nikunj/Kokkos-Resilient-Spaces", "max_issues_repo_head_hexsha": "7203d40747d1961286cb4f9ca872354f395ac601", "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": "applications/non-resilient/ABFT3D.cpp", "max_forks_repo_name": "NK-Nikunj/Kokkos-Resilient-Spaces", "max_forks_repo_head_hexsha": "7203d40747d1961286cb4f9ca872354f395ac601", "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": 33.7370689655, "max_line_length": 123, "alphanum_fraction": 0.41459052, "num_tokens": 1870, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430394931456, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.4988423771839308}} {"text": "/**\n * \\file libsanm/tensor_polymat.cpp\n * This file is part of SANM, a symbolic asymptotic numerical solver.\n */\n\n#include \"libsanm/stl.h\"\n#include \"libsanm/tensor_impl_helper.h\"\n\n#include \n#include \n#include \n#include \n#include \n\nusing namespace sanm;\n\nnamespace {\n\nusing cfp_t = std::complex;\n\n/*!\n * \\brief compute the DFT of given coeffs using the FFT algorithm\n *\n * Evaluate the polynomial defined by the \\p coeffs at the points \\f$\\omega_n^0,\n * \\ldots, \\omega_n^{n-1}\\f$ where \\f$n\\f$ is \\p nr_term and must be a power of\n * two.\n *\n * \\return the real part and the imaginary part\n */\nstd::pair fft(const TensorArray& coeffs,\n size_t nr_term) {\n sanm_assert(!(nr_term & (nr_term - 1)));\n if (coeffs.size() == 1) {\n return {TensorArray(nr_term, coeffs[0]),\n TensorArray(nr_term, coeffs[0].fill_with(0))};\n }\n if (nr_term == 1) {\n TensorND sum = coeffs[0];\n for (size_t i = 1; i < coeffs.size(); ++i) {\n sum += coeffs[i];\n }\n return {{sum}, {sum.fill_with(0)}};\n }\n\n TensorArray coeffs_even, coeffs_odd;\n coeffs_even.reserve((coeffs.size() + 1) / 2);\n coeffs_odd.reserve(coeffs.size() / 2);\n for (size_t i = 0; i < coeffs.size(); i += 2) {\n coeffs_even.emplace_back(coeffs[i]);\n if (i + 1 < coeffs.size()) {\n coeffs_odd.emplace_back(coeffs[i + 1]);\n }\n }\n\n auto result_even = fft(coeffs_even, nr_term / 2),\n result_odd = fft(coeffs_odd, nr_term / 2);\n\n TensorArray ret_real(nr_term), ret_imag(nr_term);\n for (size_t si = 0; si < nr_term / 2; ++si) {\n const TensorND& a_real = result_even.first[si];\n const TensorND& a_imag = result_even.second[si];\n const TensorND& b_real = result_odd.first[si];\n const TensorND& b_imag = result_odd.second[si];\n\n for (size_t i : {si, si + nr_term / 2}) {\n TensorND& y_real = ret_real[i];\n TensorND& y_imag = ret_imag[i];\n\n fp_t angle = fp_t(i) * (M_PI * 2) / fp_t(nr_term),\n x_real = std::cos(angle), x_imag = std::sin(angle);\n\n // y = a + x * b\n y_real.set_shape(coeffs[0].shape());\n y_imag.set_shape(coeffs[0].shape());\n as_vector_w(y_real) = as_vector_r(a_real) +\n as_vector_r(b_real) * x_real -\n as_vector_r(b_imag) * x_imag;\n as_vector_w(y_imag) = as_vector_r(a_imag) +\n as_vector_r(b_imag) * x_real +\n as_vector_r(b_real) * x_imag;\n }\n }\n return {std::move(ret_real), std::move(ret_imag)};\n}\n\nsize_t next_pow2(size_t x) {\n size_t y = 1;\n while (y < x) {\n y <<= 1;\n }\n return y;\n}\n\nTensorND compute_polymat_det_coeff_with_fft(const TensorArray& coeffs,\n size_t nr_term_pow2,\n size_t target_order) {\n std::pair polymat_dft;\n {\n SANM_SCOPED_PROFILER(\"polymat_det_fft\");\n polymat_dft = fft(coeffs, nr_term_pow2);\n }\n\n const size_t batch = coeffs[0].shape(0);\n const Eigen::Index mdim = coeffs[0].shape(1);\n ScopedAllowMalloc allow_malloc;\n Eigen::Matrix eigmat(mdim, mdim);\n\n TensorND ret{TensorShape{batch, 1}};\n auto ret_ptr = ret.woptr();\n for (size_t ib = 0; ib < batch; ++ib) {\n // do the inverse dft to solve the target coefficient\n cfp_t accum = 0;\n for (size_t i = 0; i < nr_term_pow2; ++i) {\n EigenMatDyn mreal{const_cast(polymat_dft.first[i].ptr()) +\n ib * mdim * mdim,\n mdim, mdim},\n mimag{const_cast(polymat_dft.second[i].ptr()) +\n ib * mdim * mdim,\n mdim, mdim};\n eigmat.real() = mreal;\n eigmat.imag() = mimag;\n cfp_t dfti = eigmat.determinant();\n fp_t angle =\n -(M_PI * 2) * fp_t(i * target_order) / fp_t(nr_term_pow2);\n accum += dfti * cfp_t{std::cos(angle), std::sin(angle)};\n }\n accum /= fp_t(nr_term_pow2);\n sanm_assert(std::fabs(accum.imag()) <\n 1e-4 * std::max(1, std::fabs(accum.real())),\n \"IDFT not real: real=%g imag=%g\", accum.real(),\n accum.imag());\n ret_ptr[ib] = accum.real();\n }\n\n return ret;\n}\n\nTensorArray transpose_coeffs(const TensorArray& coeffs) {\n TensorArray ret;\n ret.resize(coeffs.size());\n for (size_t i = 0; i < coeffs.size(); ++i) {\n TensorND& dst = ret[i];\n const TensorND& src = coeffs[i];\n sanm_assert(src.rank() == 3);\n size_t n = src.shape(0), m0 = src.shape(1), m1 = src.shape(2);\n dst.set_shape({m0, m1, n});\n EigenMatDyn mdst{dst.woptr(), static_cast(n),\n static_cast(m0 * m1)},\n msrc{const_cast(src.ptr()),\n static_cast(m0 * m1),\n static_cast(n)};\n mdst = msrc.transpose();\n }\n return ret;\n}\n\nusing EigenVecArr = std::span;\n\nvoid conv(EigenVecArr dst, EigenVecArr x, EigenVecArr y) {\n for (EigenVec& i : dst) {\n i.setZero();\n }\n for (size_t i = 0; i < x.size(); ++i) {\n for (size_t j = 0; j < y.size() && i + j < dst.size(); ++j) {\n dst[i + j].array() += x[i].array() * y[j].array();\n }\n }\n}\n\nvoid conv_k(size_t k, EigenVec& dst, EigenVecArr x, EigenVecArr y) {\n bool first = true;\n for (size_t i = std::max(0, int(k) + 1 - int(y.size()));\n i < x.size() && i <= k; ++i) {\n if (first) {\n dst = x[i].array() * y[k - i].array();\n first = false;\n } else {\n dst.array() += x[i].array() * y[k - i].array();\n }\n }\n if (first) {\n dst.setZero();\n }\n}\n\nclass EigenVecArrStorage : public ObjArray {\npublic:\n explicit EigenVecArrStorage(size_t size)\n : ObjArray(size, nullptr, 0, 1) {}\n};\n\n/*!\n * \\brief Compute a single term in the expansion of determinant\n *\n * The result is the product of mat[i][row_indices[i]]\n * Result is negated if row_indices[0]<0 or row_indices[1]<0\n *\n * \\param coeffs_trans transposed coefficients in (m, m, batch) shape\n * \\param k target term order\n */\nclass DetSingleTermCompute {\n TensorArray m_coeffs_trans;\n const size_t m_batch;\n const size_t m_k;\n std::unique_ptr m_buf_storage;\n TensorND m_ret;\n EigenVecArrStorage m_buf0, m_buf1, m_opr0, m_opr1;\n\npublic:\n DetSingleTermCompute(const TensorArray& coeffs, size_t k)\n : m_coeffs_trans{transpose_coeffs(coeffs)},\n m_batch{m_coeffs_trans[0].shape(2)},\n m_k{k},\n m_buf_storage{new fp_t[2 * (k + 1) * m_batch]},\n m_ret{TensorShape{m_batch, 1}},\n m_buf0{k + 1},\n m_buf1{k + 1},\n m_opr0{coeffs.size()},\n m_opr1{coeffs.size()} {\n auto ptr = m_buf_storage.get();\n for (size_t i = 0; i <= k; ++i) {\n reset(m_buf0[i], ptr + (i * 2) * m_batch, m_batch);\n reset(m_buf1[i], ptr + (i * 2 + 1) * m_batch, m_batch);\n }\n }\n\n TensorND operator()(std::span row_indices) {\n auto extract = [&row_indices, this, msize = m_coeffs_trans[0].shape(1)](\n EigenVecArr dst, int r) {\n for (size_t i = 0; i < m_coeffs_trans.size(); ++i) {\n size_t c = std::abs(row_indices[r]);\n reset(dst[i],\n m_coeffs_trans[i].ptr() + (r * msize + c) * m_batch,\n m_batch);\n }\n };\n\n auto conv_ret = [this, &row_indices](EigenVecArr x, EigenVecArr y) {\n auto ret_vec = as_vector_w(m_ret);\n conv_k(m_k, ret_vec, x, y);\n if (row_indices[0] < 0 || row_indices[1] < 0) {\n m_ret.inplace_neg();\n }\n return m_ret;\n };\n\n extract(m_opr0, 0);\n extract(m_opr1, 1);\n if (row_indices.size() == 2) {\n return conv_ret(m_opr0, m_opr1);\n }\n\n EigenVecArrStorage *prod = &m_buf0, *prod_next = &m_buf1;\n conv(*prod, m_opr0, m_opr1);\n\n for (size_t i = 2; i + 1 < row_indices.size(); ++i) {\n extract(m_opr0, i);\n conv(*prod_next, *prod, m_opr0);\n std::swap(prod, prod_next);\n }\n extract(m_opr0, row_indices.size() - 1);\n return conv_ret(*prod, m_opr0);\n }\n};\n\n/*!\n * \\brief get the terms in the expansion of determinant\n * \\return vector of size m! * m; the sign of items i*m are the sign of the\n * terms\n */\nconst std::vector& get_det_terms(size_t m) {\n static std::mutex mutex;\n static std::vector> results{std::vector{0}};\n static auto compute = [&](int size) {\n sanm_assert(results.size() == static_cast(size - 1));\n std::vector& cur = results.emplace_back();\n const auto& prev = results[size - 2];\n for (int i = 0; i < size; ++i) {\n for (size_t j = 0; j < prev.size();) {\n size_t r0 = cur.size();\n bool neg = i % 2;\n cur.push_back(i);\n for (int jdt = 0; jdt < size - 1; ++jdt) {\n int p = prev[j + jdt];\n if (p < 0) {\n neg = !neg;\n p = -p;\n }\n cur.push_back(p + (p >= i));\n }\n if (neg) {\n if (cur[r0]) {\n cur[r0] = -cur[r0];\n } else {\n cur[r0 + 1] = -cur[r0 + 1];\n }\n }\n j += size - 1;\n }\n }\n#if 0\n printf(\"det(%d):\\n\", size);\n for (size_t i = 0; i < cur.size(); ++i) {\n printf(\"%d\", cur[i]);\n if ((i + 1) % size == 0) {\n printf(\"\\n\");\n } else {\n printf(\" \");\n }\n }\n#endif\n };\n\n sanm_assert(m >= 1);\n std::lock_guard mutex_lg{mutex};\n if (m - 1 < results.size()) {\n return results[m - 1];\n }\n for (size_t i = results.size() + 1; i <= m; ++i) {\n compute(i);\n }\n return results[m - 1];\n}\n\nTensorND compute_polymat_det_coeff_by_expanding(const TensorArray& coeffs,\n size_t target_order) {\n DetSingleTermCompute tc{coeffs, target_order};\n size_t m = coeffs[0].shape(1);\n const auto& terms = get_det_terms(m);\n\n TensorND ret;\n for (size_t i = 0; i < terms.size(); i += m) {\n TensorND cur = tc({terms.data() + i, m});\n if (!i) {\n ret = cur;\n } else {\n ret += cur;\n }\n }\n return ret;\n}\n} // anonymous namespace\n\nTensorND sanm::compute_polymat_det_coeff(const TensorArray& coeffs,\n size_t order) {\n SANM_SCOPED_PROFILER(\"polymat_det\");\n sanm_assert(!coeffs.empty() && coeffs[0].rank() == 3 &&\n coeffs[0].shape(1) == coeffs[0].shape(2));\n for (size_t i = 1; i < coeffs.size(); ++i) {\n sanm_assert(coeffs[i].shape() == coeffs[0].shape());\n }\n\n const size_t batch = coeffs[0].shape(0), mdim = coeffs[0].shape(1),\n nr_term = (coeffs.size() - 1) * mdim + 1;\n sanm_assert(mdim >= 2);\n\n if (order >= nr_term) {\n return TensorND{TensorShape{batch, 1}}.fill_with_inplace(0);\n }\n if (order == 0) {\n return coeffs[0].batched_determinant();\n }\n if (order == 1) {\n TensorND ret{TensorShape{batch, 1}},\n src = coeffs[0].batched_cofactor() * coeffs[1];\n EigenMatDyn smat{const_cast(src.ptr()),\n static_cast(mdim * mdim),\n static_cast(batch)};\n as_vector_w(ret) = smat.colwise().sum().transpose();\n return ret;\n }\n\n if (mdim <= 4) {\n return compute_polymat_det_coeff_by_expanding(coeffs, order);\n }\n\n return compute_polymat_det_coeff_with_fft(coeffs, next_pow2(nr_term),\n order);\n}\n", "meta": {"hexsha": "97fca3ecfdff01823e49b16ff08ef22058acd184", "size": 12639, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libsanm/tensor_polymat.cpp", "max_stars_repo_name": "jia-kai/SANM", "max_stars_repo_head_hexsha": "2673ac476b3d2978a52bf47bc12d3402ea20f211", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 25.0, "max_stars_repo_stars_event_min_datetime": "2021-05-19T09:27:52.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T15:22:05.000Z", "max_issues_repo_path": "libsanm/tensor_polymat.cpp", "max_issues_repo_name": "jia-kai/SANM", "max_issues_repo_head_hexsha": "2673ac476b3d2978a52bf47bc12d3402ea20f211", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-09-03T05:31:47.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-05T01:37:42.000Z", "max_forks_repo_path": "libsanm/tensor_polymat.cpp", "max_forks_repo_name": "jia-kai/SANM", "max_forks_repo_head_hexsha": "2673ac476b3d2978a52bf47bc12d3402ea20f211", "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.2605263158, "max_line_length": 80, "alphanum_fraction": 0.5093757418, "num_tokens": 3455, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430353105599, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.49884237467359155}} {"text": "\n/*=========================================================================\n\n Program: Small Body Geophysical Analysis\n Module: SBGATSphericalHarmo.hpp\n\n Class derived from VTK's vtkPolyDataAlgorithm by Benjamin Bercovici \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 @class SBGATSphericalHarmo\n @author Benjamin Bercovici\n @author Jay McMahon\n@date October 2018\n @brief Computes/evaluates the outer spherical harmonics expansion of the exterior gravity\n field around a constant density polyhedron\n\n @details Computes/evaluates the outer spherical harmonics expansion of the exterior gravity\nfield around a constant density polyhedron. Normalized or non-normalized coefficients can be computed.\nThe computed coefficients are completely independent of the mass and density of the considered object\nas they are only a geometric construct, thanks to the constant-density assumption. This class will always use results expressed in `meters` as their distance unit (e.g accelerations in m/s^2, potentials in m^2/s^2,...) . Unit consistency is enforced through the use of the SetScaleMeters()\nand SetScaleKiloMeters() method. \n\nAdapted from the works of Yu Takahashi and Siamak Hesar by Benjamin Bercovici, University of Colorado Boulder\nfor more details, see \nWerner, R. a. (1997). \nSpherical harmonic coefficients for the potential of a constant-density polyhedron. \nComputers & Geosciences, \n23(10), \n1071–1077. \nhttps://doi.org/10.1016/S0098-3004(97)00110-6\n@copyright MIT License, Benjamin Bercovici and Jay McMahon\n*/\n\n#ifndef SBGATSphericalHarmo_h\n#define SBGATSphericalHarmo_h\n\n#include // For export macro\n#include \n#include \n\nclass VTKFILTERSCORE_EXPORT SBGATSphericalHarmo : public vtkPolyDataAlgorithm{\npublic:\n /**\n * Constructs with initial values of zero.\n */\n static SBGATSphericalHarmo *New();\n\n vtkTypeMacro(SBGATSphericalHarmo,vtkPolyDataAlgorithm);\n void PrintSelf(std::ostream& os, vtkIndent indent) override;\n void PrintHeader(std::ostream& os, vtkIndent indent) override;\n void PrintTrailer(std::ostream& os, vtkIndent indent) override;\n\n /**\n Sets degree of spherical harmonics expansion\n @param deg degree of spherical harmonics expansion\n */\n void SetDegree(const unsigned int deg){\n this -> degree = deg;\n this -> degreeSet = true;\n }\n\n /**\n Sets reference radius in spherical harmonics expansion. Must be consistent \n with the units in which the shape coordinates are expressed\n @param ref_radius reference radius in spherical harmonics expansion\n */\n void SetReferenceRadius(const double ref_radius){\n this -> referenceRadius = ref_radius;\n this -> referenceRadiusSet = true;\n }\n\n /**\n Sets polyhedron density \n @param density bulk density of polyhedron (kg/m^3)\n */\n void SetDensity(const double density){\n this -> density = density;\n this -> densitySet = true;\n }\n\n\n /*\n Will return normalized coefficients next (default is normalized)\n */\n void IsNormalized(){\n this -> normalized = true;\n }\n\n /*\n Will return non-normalized coefficients next (default is normalized)\n */\n void IsNonNormalized(){\n this -> normalized = false;\n }\n\n /*\n Return Cnm array of coefficients ordered like in the exemple below where degree = 5\n\n 1 0 0 0 0 0\n C_10 C_11 C_12 C_13 C_14 C_15\n C_20 C_21 C_22 C_23 C_24 C_25 \n C_30 C_31 C_32 C_33 C_34 C_35 \n C_40 C_41 C_42 C_43 C_44 C_45\n C_50 C_51 C_52 C_53 C_54 C_55\n\n\n @return Cnm array of coefficients\n */\n arma::mat GetCnm() {this -> Update(); return this -> Cnm;}\n\n\n /*\n Return Cnm array of coefficients ordered like in the exemple below where degree = 5\n\n 1 0 0 0 0 0\n C_10 C_11 C_12 C_13 C_14 C_15\n C_20 C_21 C_22 C_23 C_24 C_25 \n C_30 C_31 C_32 C_33 C_34 C_35 \n C_40 C_41 C_42 C_43 C_44 C_45\n C_50 C_51 C_52 C_53 C_54 C_55\n\n\n @param[out] Cnm array of coefficients\n */\n void GetCnm(arma::mat & C_nm) {this -> Update(); C_nm = this -> Cnm;}\n\n\n /*\n \n Return Snm array of coefficients ordered like in the exemple below where degree = 5\n\n 0 0 0 0 0 0\n 0 S_11 S_12 S_13 S_14 S_15\n 0 S_21 S_22 S_23 S_24 S_25 \n 0 S_31 S_32 S_33 S_34 S_35 \n 0 S_41 S_42 S_43 S_44 S_45\n 0 S_51 S_52 S_53 S_54 S_55\n\n\n @return Snm array of coefficients\n */\n arma::mat GetSnm() {this -> Update(); return this -> Snm;}\n\n /*\n Return Snm array of coefficients ordered like in the exemple below where degree = 5\n\n 0 0 0 0 0 0\n 0 S_11 S_12 S_13 S_14 S_15\n 0 S_21 S_22 S_23 S_24 S_25 \n 0 S_31 S_32 S_33 S_34 S_35 \n 0 S_41 S_42 S_43 S_44 S_45\n 0 S_51 S_52 S_53 S_54 S_55\n\n @param[out] Snm array of coefficients\n */\n void GetSnm(arma::mat & S_nm) {this -> Update(); S_nm = this -> Snm;}\n\n /**\n Return the acceleration due to gravity at the specified point\n @param pos position at which the acceleration must be evaluated (meters)\n @return acceleration (m / s ^ 2)\n */\n arma::vec::fixed<3> GetAcceleration(const arma::vec::fixed<3> & pos);\n\n\n /** \n Evaluates the gravity gradient matrix (the partial derivative of the spherical \n harmonics acceleration with respect to the position vector) at the prescribed\n location. Note that this gravity gradient matrix is expressed in the body-fixed frame of the considered object.\n @param[in] pos position at which the gravity gradient matrix must be evaluated, expressed in the same frame/same unit L as \n the shape used to build the spherical harmonics expansion.\n @param[out] dAccdPos container holding the gravity gradient matrix (1 / s ^ 2)\n */\n void GetGravityGradientMatrix(const arma::vec::fixed<3> & pos,\n arma::mat::fixed<3,3> & dAccdPos);\n\n\n /** \n Evaluates the partial derivative of the spherical harmonics acceleration\n with respect to the spherical harmonics coefficients. The coefficients and the partials of the acceleration w/r to the coefficients\n are ordered like so:\n \n Cnm :\n(C_00 == 1) 0 0 0 0 0\n C_10 C_11 0 0 0 0 \n C_20 C_21 C_22 0 0 0 \n C_30 C_31 C_32 C_33 0 0 \n C_40 C_41 C_42 C_43 C_44 0\n C_50 C_51 C_52 C_53 C_54 C_55\n \n Snm :\n 0 0 0 0 0 0\n 0 S_11 0 0 0 0\n 0 S_21 S_22 0 0 0 \n 0 S_31 S_32 S_33 0 0 \n 0 S_41 S_42 S_43 S_44 0\n 0 S_51 S_52 S_53 S_54 S_55\n\n so \n\n partial_C = [ dA/C_00,dA/C_10,dA/C_11,dA/C_20,dA/C_21,dA/C_22,...]\n partial_S = [ dA/S_11,dA/C_21,dA/S_22,dA/S_31,dA/S_32,dA/S_33,...]\n\n @param[in] pos position at which the partial derivatives must be evaluated, expressed in the same frame/same unit as \n the shape used to build the spherical harmonics expansion.\n @param[out] partial_C container holding the partial derivative of the acceleration \n with respect to the Cnm spherical harmonic coefficients. If the degree/order is n, then there are (n+1) * (n + 2)/2 non-zero Cnm coefficients\n \n @param[out] partial_S container holding the partial derivative of the acceleration \n with respect to the Snm spherical harmonic coefficients. If the degree/order is n, then there are (n+1) * (n + 2)/2 - n non-zero Snm coefficients\n\n */\n void GetPartialHarmonics(const arma::vec::fixed<3> & pos,\n arma::mat & partial_C, \n arma::mat & partial_S);\n /**\n Sets the scale factor to 1, indicative that the polydata has its coordinates expressed in meters\n */\n void SetScaleMeters() { this -> scaleFactor = 1; this -> scaleFactorSet = true;}\n\n /**\n Sets the scale factor to 1000, indicative that the polydata has its coordinates expressed in kilometers\n */\n void SetScaleKiloMeters() { this -> scaleFactor = 1000; this -> scaleFactorSet = true;}\n\n\n /**\n Exports the computed spherical harmonics expansion to \n a JSON file. The saved fields are:\n - facets == number of facets\n - vertices == number of vertices\n - totalMass : {value, unit}\n - density : {value, unit}\n - reference_radius : {value, unit}\n - normalized == true if the coefficients are normalized\n - degree == degree of the spherical expansion\n - Cnm_coefs - vector of coefficients triplets {n,m,Cnm}\n - Snm_coefs - vector of coefficients triplets {n,m,Snm}\n @param path JSON file where the spherical harmonics model will be saved\n\n */\n void SaveToJson(std::string path) const;\n\n /**\n Loads a previously computed spherical harmonics expansion\n from a JSON file. Will set the appropriate fields in the SBGATSphericalHarmo object to\n allow calls to other methods. \n The loadable fields are:\n - facets == number of facets (not needed for evaluation)\n - vertices == number of vertices (not needed for evaluation)\n - totalMass : {value, unit}\n - density : {value, unit}\n - reference_radius : {value, unit}\n - normalized == true if the coefficients are normalized\n - degree == degree of the spherical expansion\n - Cnm_coefs - vector of coefficients triplets {n,m,Cnm}\n - Snm_coefs - vector of coefficients triplets {n,m,Snm}\n @param path JSON file storing the spherical harmonics model\n */\n void LoadFromJson(std::string path);\n\n /**\n Sets the Cnm coefficients. There is normally no need to use this method outside of Sbgat's tests\n @param[in] Cnm coefficients\n */\n void SetCnm(arma::mat Cnm){this ->Cnm =Cnm;}\n\n /**\n Sets the Snm coefficients. There is normally no need to use this method outside of Sbgat's tests\n @param[in] Snm coefficients\n */\n void SetSnm(arma::mat Snm){this ->Snm =Snm;}\n\n\n\nprotected:\n SBGATSphericalHarmo();\n ~SBGATSphericalHarmo() override;\n\n int RequestData(vtkInformation* request,\n vtkInformationVector** inputVector,\n vtkInformationVector* outputVector) override;\n\n arma::mat Cnm;\n arma::mat Snm;\n\n double referenceRadius;\n double density;\n double totalMass;\n double scaleFactor = 1;\n\n bool normalized;\n unsigned int degree;\n\n int n_facets;\n int n_vertices;\n\n bool degreeSet;\n bool densitySet;\n bool referenceRadiusSet;\n bool scaleFactorSet;\n bool setFromJSON;\n\nprivate:\n SBGATSphericalHarmo(const SBGATSphericalHarmo&) = delete;\n void operator=(const SBGATSphericalHarmo&) = delete;\n};\n\n#endif\n\n\n", "meta": {"hexsha": "626418cc2d286c5866d864033811dcba7f5cc9dc", "size": 10637, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "SbgatCore/include/SbgatCore/SBGATSphericalHarmo.hpp", "max_stars_repo_name": "bbercovici/SBGAT", "max_stars_repo_head_hexsha": "93e935baff49eb742470d7d593931f0573f0c062", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2017-11-29T02:47:00.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-26T05:25:44.000Z", "max_issues_repo_path": "SbgatCore/include/SbgatCore/SBGATSphericalHarmo.hpp", "max_issues_repo_name": "bbercovici/SBGAT", "max_issues_repo_head_hexsha": "93e935baff49eb742470d7d593931f0573f0c062", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 34.0, "max_issues_repo_issues_event_min_datetime": "2017-02-09T15:38:35.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-25T20:53:37.000Z", "max_forks_repo_path": "SbgatCore/include/SbgatCore/SBGATSphericalHarmo.hpp", "max_forks_repo_name": "bbercovici/SBGAT", "max_forks_repo_head_hexsha": "93e935baff49eb742470d7d593931f0573f0c062", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-03-12T12:20:25.000Z", "max_forks_repo_forks_event_max_datetime": "2019-03-12T12:20:25.000Z", "avg_line_length": 33.1370716511, "max_line_length": 289, "alphanum_fraction": 0.6935226098, "num_tokens": 3164, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577681086260461, "lm_q2_score": 0.5813030906443133, "lm_q1q2_score": 0.49862325260044765}} {"text": "#include \n#include \n#include \n#include \"larsson_iccv19.h\"\n#include \"kukelova_iccv13.h\"\n#include \"../misc/univariate.h\"\n#include \"../misc/distortion.h\"\n\nusing namespace Eigen;\nusing namespace radialpose;\nusing std::complex;\n\nstatic const double SMALL_NUMBER = 1e-8;\nstatic const double DAMP_FACTOR = 1e-8;\n\n\n\nstatic void linsolve_known_pose_dist(const Points2D &x, const Points3D &X, double t3, int Np, int Nd, double damp, Camera* camera)\n{\n\tint n_pts = x.cols();\n\tint n_param = 1 + Np + Nd;\n\n\tint n_rows = n_pts;\n\tif (damp > 0)\n\t\tn_rows += n_param - 1;\n\n\t// System matrix for normal equations\n\tEigen::Matrix A(n_rows, n_param);\n\tEigen::Matrix b(n_rows, 1);\n\tA.setZero(); b.setZero();\n\n\tdouble r_pow[4];\n\tfor (int i = 0; i < n_pts; i++) {\n\n\t\tdouble uu, uv;\n\t\tif (std::abs(x(0, i)) < SMALL_NUMBER) {\n\t\t\tuv = x(1, i);\n\t\t\tuu = X(1, i) / (t3 + X(2, i));\n\t\t}\n\t\telse {\n\t\t\tuv = x(0, i);\n\t\t\tuu = X(0, i) / (t3 + X(2, i));\n\t\t}\n\n\t\t//double rd2 = x(0, i) * x(0, i) + x(1, i) * x(1, i);\n\t\tdouble ru2 = (X(0, i) * X(0, i) + X(1, i) * X(1, i)) / ((X(2, i) + t3) * (X(2, i) + t3));\t\t\t\t\n\n\t\t// compute powers\n\t\tr_pow[0] = ru2; // r^2\n\t\tr_pow[1] = ru2 * ru2; // r^4\n\t\tr_pow[2] = ru2 * r_pow[1]; // r^6\n\t\tr_pow[3] = ru2 * r_pow[2]; // r^8\n\n\t\tA(i, 0) = uu;\n\t\tfor (int k = 0; k < Np; k++)\n\t\t\tA(i, 1 + k) = r_pow[k] * uu;\n\t\tfor (int k = 0; k < Nd; k++)\n\t\t\tA(i, 1 + Np + k) = -uv * r_pow[k];\n\t\tb(i) = uv;\n\t}\n\tif (damp > 0) {\n\t\tfor (int i = 1; i < n_param; i++)\n\t\t\tA(n_pts - 1 + i, i) += damp;\n\t}\n\n\t//Eigen::JacobiSVD> svd(A);\t\n\t//std::cout << \"A: \" << A << \"\\n\";\n\t//std::cout << \"svd(A): \" << svd.singularValues() << \"\\n\";\n\n\tEigen::Matrix sol = A.fullPivHouseholderQr().solve(b);\n\tcamera->focal = sol(0);\n\tfor (int i = 1; i < n_param; i++) {\n\t\tif (i <= Np)\n\t\t\tcamera->dist_params.push_back(sol(i) / camera->focal);\n\t\telse\n\t\t\tcamera->dist_params.push_back(sol(i));\n\t}\n}\n\nstatic void linsolve_known_pose_undist(const Points2D &x, const Points3D &X, double t3, int Np, int Nd, double damp, Camera* camera)\n{\n\tint n_pts = x.cols();\n\tint n_param = 1 + Np + Nd;\n\n\tint n_rows = n_pts;\n\tif (damp > 0)\n\t\tn_rows += n_param - 1;\n\n\t// System matrix for normal equations\n\tEigen::Matrix A(n_rows, n_param);\n\tEigen::Matrix b(n_rows, 1);\n\tA.setZero(); b.setZero();\n\n\tdouble r_pow[4];\n\tfor (int i = 0; i < n_pts; i++) {\n\n\t\tdouble uu, uv;\n\t\tif (std::abs(x(0, i)) < SMALL_NUMBER) {\n\t\t\tuv = x(1, i);\n\t\t\tuu = X(1, i) / (t3 + X(2, i));\n\t\t} else {\n\t\t\tuv = x(0, i);\n\t\t\tuu = X(0, i) / (t3 + X(2, i));\n\t\t}\n\n\t\tdouble rd2 = x(0, i) * x(0, i) + x(1, i) * x(1, i);\t\t\n\t\t\t\n\t\t// compute powers\n\t\tr_pow[0] = rd2; // r^2\n\t\tr_pow[1] = rd2 * rd2; // r^4\n\t\tr_pow[2] = rd2 * r_pow[1]; // r^6\n\t\tr_pow[3] = rd2 * r_pow[2]; // r^8\n\n\t\tA(i, 0) = uu;\n\t\tfor (int k = 0; k < Np; k++)\n\t\t\tA(i, 1 + k) = -r_pow[k] * uv;\n\t\tfor (int k = 0; k < Nd; k++)\n\t\t\tA(i, 1 + Np + k) = uu * r_pow[k];\n\t\tb(i) = uv;\n\t}\n\tif (damp > 0) {\n\t\tfor (int i = 1; i < n_param; i++)\n\t\t\tA(n_pts - 1 + i, i) += damp;\n\t}\n\n\n\tEigen::Matrix sol = A.fullPivHouseholderQr().solve(b);\n\tcamera->focal = sol(0);\n\tdouble f2 = camera->focal * camera->focal;\n\tdouble f2k = f2;\n\t// We have the real mu_k = sol * f^2k and lambda_k = sol * f^2k-1\n\tfor (int i = 1; i < n_param; i++) {\n\t\tif (i == Np+1)\n\t\t\tf2k = camera->focal;\n\t\tcamera->dist_params.push_back(sol(i) * f2k);\n\t\tf2k = f2k * f2;\n\t}\n}\n\n\n// Small refinement on the minimal sample. TODO: Move this to refinement.cc\ntemplate\nvoid radial_refinement_dist(Camera &p, const Points2D &x, const Points3D &X, double damp_factor) {\n\t// It is assumed that X is already rotated by p\n\tconstexpr int n_pts = std::max(2 + Np + Nd, 5);\n\n\tMatrix J;\n\tMatrix res;\n\tMatrix dx;\n\n\tfor (int i = 0; i < Np; ++i)\n\t\tp.dist_params[i] *= p.focal;\n\n\tfor (int iter = 0; iter < 5; ++iter) {\n\t\tfor (int i = 0; i < n_pts; ++i) {\n\t\t\tdouble d = X(2, i) + p.t(2);\n\t\t\tdouble d2 = d * d;\n\t\t\tdouble r2 = X.block<2, 1>(0, i).squaredNorm();\n\n\t\t\tdouble num = p.focal;\n\t\t\tdouble denom = d;\n\n\t\t\tdouble dnum_dt = 0.0;\n\t\t\tdouble ddenom_dt = 1.0;\n\n\n\t\t\tfor (int k = 0; k < Np; k++) {\n\t\t\t\tdouble r2d2 = std::pow(r2 / d2, k + 1);\n\n\t\t\t\tnum += p.dist_params[k] * r2d2;\n\t\t\t\tdnum_dt += - p.dist_params[k] * 2 * (k + 1) * r2d2 / d;\n\n\t\t\t}\n\t\t\tfor (int k = 0; k < Nd; k++) {\n\t\t\t\tdouble r2d2 = std::pow(r2 / d2, k + 1);\n\n\t\t\t\tdenom += d * p.dist_params[Np + k] * r2d2;\n\t\t\t\tddenom_dt += -p.dist_params[Np + k] * (2 * k + 1)*r2d2;\n\t\t\t}\n\n\t\t\tdouble factor = num / denom;\n\t\t\tdouble dfactor_dt = (dnum_dt*denom - num * ddenom_dt) / (denom*denom);\n\t\t\tdouble dfactor_df = 1 / denom;\n\n\t\t\tres(2 * i + 0) = factor * X(0, i) - x(0, i);\n\t\t\tres(2 * i + 1) = factor * X(1, i) - x(1, i);\n\n\t\t\tJ(2 * i + 0, 0) = dfactor_dt * X(0, i);\n\t\t\tJ(2 * i + 1, 0) = dfactor_dt * X(1, i);\n\t\t\tJ(2 * i + 0, 1) = dfactor_df * X(0, i);\n\t\t\tJ(2 * i + 1, 1) = dfactor_df * X(1, i);\n\n\t\t\tfor (int k = 0; k < Np; ++k) {\n\t\t\t\tdouble r2d2 = std::pow(r2 / d2, k + 1);\n\t\t\t\tdouble dfactor_dmu = r2d2 / denom;\n\n\t\t\t\tJ(2 * i + 0, 2 + k) = dfactor_dmu * X(0, i);\n\t\t\t\tJ(2 * i + 1, 2 + k) = dfactor_dmu * X(1, i);\n\t\t\t}\n\n\t\t\tfor (int k = 0; k < Nd; ++k) {\n\t\t\t\tdouble r2d2 = std::pow(r2 / d2, k + 1);\n\t\t\t\tdouble dfactor_dlambda = -d * r2d2 * num / (denom*denom);\n\t\t\t\tJ(2 * i + 0, 2 + Np + k) = dfactor_dlambda * X(0, i);\n\t\t\t\tJ(2 * i + 1, 2 + Np + k) = dfactor_dlambda * X(1, i);\n\t\t\t}\n\n\t\t}\n\n\t\tif (res.norm() < SMALL_NUMBER)\n\t\t\tbreak;\n\n\t\t//std::cout << \"res = \" << res << \"\\n\";\n\t\t//std::cout << \"jac = \" << J << \"\\n\";\n\n\t\tMatrix H = J.transpose()*J;\n\t\tH.diagonal().array() += 1e-6; // LM dampening\n\t\tMatrix g = -J.transpose()*res;\n\n\t\tif (Nd > 0 && Np > 0 && damp_factor > 0) {\n\t\t\t// For rational models we add a small dampening factor\t\t\t\n\t\t\tH.template block(2, 2).diagonal().array() += damp_factor;\n\t\t\tfor(int i = 0; i < Np+Nd; i++)\n\t\t\t\tg(2+i) -= damp_factor * p.dist_params[i];\n\t\t}\n\n\n\t\tdx = H.ldlt().solve(g);\n\n\t\tp.t(2) += dx(0);\n\t\tp.focal += dx(1);\n\t\tfor (int i = 0; i < Np; ++i)\n\t\t\tp.dist_params[i] += dx(2 + i);\n\t\tfor (int i = 0; i < Nd; ++i)\n\t\t\tp.dist_params[i + Np] += dx(Np + 2 + i);\n\n\t\tif (dx.array().abs().maxCoeff() < SMALL_NUMBER)\n\t\t\tbreak;\n\t}\n\n\tfor (int i = 0; i < Np; ++i)\n\t\tp.dist_params[i] /= p.focal;\n}\n\n\ntemplate\nvoid radial_refinement_undist(Camera &p, const Points2D &x, const Points3D &X, double damp_factor) {\n\t// It is assumed that X is already rotated by p\n\tconstexpr int n_pts = std::max(2 + Np + Nd, 5);\n\n\tMatrix J;\n\tMatrix res;\n\tMatrix dx;\n\n\t// Change of variables\n\tdouble f2 = p.focal * p.focal;\n\tdouble f2k = f2;\n\tfor (int i = 0; i < Np; ++i) {\n\t\tp.dist_params[i] /= f2k;\n\t\tf2k *= f2;\n\t}\n\tf2k = p.focal;\n\tfor (int i = 0; i < Nd; ++i) {\n\t\tp.dist_params[Np + i] /= f2k;\n\t\tf2k *= f2;\n\t}\n\n\tdouble r_pow[3];\n\n\tfor (int iter = 0; iter < 5; ++iter) {\n\t\tfor (int i = 0; i < n_pts; ++i) {\n\t\t\tdouble d = X(2, i) + p.t(2);\n\t\t\tdouble r2 = x.col(i).squaredNorm();\n\n\t\t\tdouble num = 1.0;\n\t\t\tdouble denom = p.focal;\n\n\t\t\tr_pow[0] = r2; // 2\n\t\t\tr_pow[1] = r2 * r2; // 4\n\t\t\tr_pow[2] = r2 * r_pow[1]; // 6\n\n\n\t\t\tfor (int k = 0; k < Np; k++) {\n\t\t\t\tnum += p.dist_params[k] * r_pow[k];\n\t\t\t}\n\t\t\tfor (int k = 0; k < Nd; k++) {\n\t\t\t\tdenom += p.dist_params[Np + k] * r_pow[k];\n\t\t\t}\n\n\t\t\tdouble factor = num / denom;\n\n\t\t\tdouble dfactor_df = -factor / denom;\n\n\t\t\tres(2 * i + 0) = factor * x(0, i) - X(0, i) / d;\n\t\t\tres(2 * i + 1) = factor * x(1, i) - X(1, i) / d;\n\n\t\t\tJ(2 * i + 0, 0) = X(0, i) / (d*d); // t\n\t\t\tJ(2 * i + 1, 0) = X(1, i) / (d*d);\n\t\t\tJ(2 * i + 0, 1) = dfactor_df * x(0, i);\n\t\t\tJ(2 * i + 1, 1) = dfactor_df * x(1, i);\n\n\t\t\tfor (int k = 0; k < Np; ++k) {\n\t\t\t\tdouble dfactor_dmu = r_pow[k] / denom;\n\t\t\t\tJ(2 * i + 0, 2 + k) = dfactor_dmu * x(0, i);\n\t\t\t\tJ(2 * i + 1, 2 + k) = dfactor_dmu * x(1, i);\n\t\t\t}\n\t\t\tfor (int k = 0; k < Nd; ++k) {\n\t\t\t\tdouble dfactor_dlambda = -r_pow[k] * num / (denom*denom);\n\t\t\t\tJ(2 * i + 0, 2 + Np + k) = dfactor_dlambda * x(0, i);\n\t\t\t\tJ(2 * i + 1, 2 + Np + k) = dfactor_dlambda * x(1, i);\n\t\t\t}\n\t\t}\n\n\t\t//std::cout << \"res = \" << res << \"\\n\";\n\t\t//std::cout << \"jac = \" << J << \"\\n\";\n\t\tif (res.norm() < SMALL_NUMBER)\n\t\t\tbreak;\n\n\t\tMatrix H = J.transpose()*J;\n\t\tH.diagonal().array() += 1e-6; // LM dampening\n\t\tMatrix g = -J.transpose()*res;\n\n\t\tif (Nd > 0 && Np > 0 && damp_factor > 0) {\n\t\t\t// For rational models we add a small dampening factor\n\t\t\tH.template block(2, 2).diagonal().array() += damp_factor;\n\t\t\tfor (int i = 0; i < Np + Nd; i++)\n\t\t\t\tg(2 + i) -= damp_factor * p.dist_params[i];\n\t\t}\n\n\n\t\tdx = H.ldlt().solve(g);\n\n\t\tp.t(2) += dx(0);\n\t\tp.focal += dx(1);\n\t\tfor (int i = 0; i < Np; ++i)\n\t\t\tp.dist_params[i] += dx(2 + i);\n\t\tfor (int i = 0; i < Nd; ++i)\n\t\t\tp.dist_params[i + Np] += dx(Np + 2 + i);\n\n\t\tif (dx.array().abs().maxCoeff() < SMALL_NUMBER)\n\t\t\tbreak;\n\t}\n\n\t// Revert change of variables\n\tf2 = p.focal * p.focal;\n\tf2k = f2;\n\tfor (int i = 0; i < Np; ++i) {\n\t\tp.dist_params[i] *= f2k;\n\t\tf2k *= f2;\n\t}\n\tf2k = p.focal;\n\tfor (int i = 0; i < Nd; ++i) {\n\t\tp.dist_params[Np + i] *= f2k;\n\t\tf2k *= f2;\n\t}\n}\n\ninline double simple_preconditioner(const Points2D &x, const Points3D &X) {\n\t// Simple preconditioner using the first two points\n\tdouble nx1 = x.col(0).squaredNorm();\n\tdouble nx2 = x.col(1).squaredNorm();\n\tdouble sx1 = X.block<2, 1>(0, 0).dot(x.col(0));\n\tdouble sx2 = X.block<2, 1>(0, 1).dot(x.col(1));\n\treturn (X(2, 1)*nx2*sx1 - X(2, 0)*nx1*sx2) / (nx1 * sx2 - nx2 * sx1);\n}\n\ntemplate\nint radialpose::larsson_iccv19::Solver::solve(const Points2D& image_points, const Points3D& world_points, std::vector* poses) const\n{\n\n\tstd::vector initial_poses;\n\tstd::vector t3;\n\n\tif (use_radial_solver) {\n\t\tkukelova_iccv13::Radial1DSolver::p5p_radial_impl(image_points, world_points, &initial_poses);\n\t} else {\n\t\tinitial_poses.push_back(Camera(Matrix3d::Identity(), Vector3d::Zero()));\n\t}\n\tMatrix X;\n\n\tfor (int k = 0; k < initial_poses.size(); k++) {\n\t\tt3.clear();\n\n\t\tX = initial_poses[k].R * world_points;\n\t\tX.colwise() += initial_poses[k].t;\n\n\t\t//std::cout << \"Initial pose \" << k + 1 << \"/\" << initial_poses.size() << \"\\n\";\n\t\t//std::cout << \"R=\" << initial_poses[k].R << \"\\nt=\" << initial_poses[k].t << \"\\n\";\n\t\t//std::cout << \"X=\" << X << \"\\n\";\n\n\t\tdouble t0 = 0;\n\t\tif (use_precond) {\n\t\t\tt0 = simple_preconditioner(image_points, X);\n\t\t\tX.row(2).array() += t0;\n\t\t}\n\n\t\tsolver_impl(image_points, X, &t3);\n\n\t\tfor (int i = 0; i < t3.size(); ++i) {\n\t\t\tCamera pose;\n\t\t\tpose.R = initial_poses[k].R;\n\t\t\tpose.t = initial_poses[k].t;\n\t\t\tpose.t(2) = t3[i];\n\n\t\t\tif (DistortionModel) {\n\t\t\t\tlinsolve_known_pose_dist(image_points, X, t3[i], Np, Nd, damp_factor, &pose);\n\t\t\t\tif(root_refinement)\n\t\t\t\t\tradial_refinement_dist(pose, image_points, X, damp_factor);\n\t\t\t} else {\n\t\t\t\tlinsolve_known_pose_undist(image_points, X, t3[i], Np, Nd, damp_factor, &pose);\n\t\t\t\tif(root_refinement)\n\t\t\t\t\tradial_refinement_undist(pose, image_points, X, damp_factor);\n\t\t\t}\t\t\t\n\n\t\t\tif (pose.focal < 0) {\n\t\t\t\t// flipped solution\n\t\t\t\tpose.focal = -pose.focal;\n\t\t\t\tpose.R.row(0) = -pose.R.row(0);\n\t\t\t\tpose.R.row(1) = -pose.R.row(1);\n\t\t\t\tpose.t(0) = -pose.t(0);\n\t\t\t\tpose.t(1) = -pose.t(1);\n\t\t\t}\n\n\t\t\t\n\t\t\t// Revert precond\n\t\t\tpose.t(2) += t0;\n\n\t\t\t//std::cout << \"solution[\" << i << \"], t3=\" << pose.t(2) << \"\\n\";\n\t\t\tposes->push_back(pose);\n\t\t}\n\t}\n\treturn poses->size();\n}\n\n\n\n\n// Template instantiations\ntemplate class radialpose::larsson_iccv19::Solver<1, 0, true>;\ntemplate class radialpose::larsson_iccv19::Solver<2, 0, true>;\ntemplate class radialpose::larsson_iccv19::Solver<3, 0, true>;\ntemplate class radialpose::larsson_iccv19::Solver<3, 3, true>;\ntemplate class radialpose::larsson_iccv19::Solver<1, 0, false>;\n//template class radialpose::larsson_iccv19::Solver<2, 0, false>;\n//template class radialpose::larsson_iccv19::Solver<3, 0, false>;\n//template class radialpose::larsson_iccv19::Solver<3, 3, false>;\n\ntemplate class radialpose::PoseEstimator>;\ntemplate class radialpose::PoseEstimator>;\ntemplate class radialpose::PoseEstimator>;\ntemplate class radialpose::PoseEstimator>;\ntemplate class radialpose::PoseEstimator>;\n\n/*\n This is broken?\n// These are implemented in larsson_iccv19_impl.cc\nextern template int radialpose::larsson_iccv19::Solver<1, 0, true>::solver_impl(Eigen::Matrix, Eigen::Matrix, std::vector*);\nextern template int radialpose::larsson_iccv19::Solver<2, 0, true>::solver_impl(Eigen::Matrix, Eigen::Matrix, std::vector*);\nextern template int radialpose::larsson_iccv19::Solver<3, 0, true>::solver_impl(Eigen::Matrix, Eigen::Matrix, std::vector*);\nextern template int radialpose::larsson_iccv19::Solver<3, 3, true>::solver_impl(Eigen::Matrix, Eigen::Matrix, std::vector*);\nextern template int radialpose::larsson_iccv19::Solver<1, 0, false>::solver_impl(Eigen::Matrix, Eigen::Matrix, std::vector*);\n*/", "meta": {"hexsha": "b8bbcf263066dc2af85246adcb336c2c6602d03f", "size": 13757, "ext": "cc", "lang": "C++", "max_stars_repo_path": "solvers/larsson_iccv19.cc", "max_stars_repo_name": "vlarsson/radialpose", "max_stars_repo_head_hexsha": "e620fc208f573820ade6a6fe321731d0f3eb082d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 34.0, "max_stars_repo_stars_event_min_datetime": "2019-10-29T02:48:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T20:28:29.000Z", "max_issues_repo_path": "solvers/larsson_iccv19.cc", "max_issues_repo_name": "vlarsson/radialpose", "max_issues_repo_head_hexsha": "e620fc208f573820ade6a6fe321731d0f3eb082d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-05-31T16:16:04.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-31T19:39:41.000Z", "max_forks_repo_path": "solvers/larsson_iccv19.cc", "max_forks_repo_name": "vlarsson/radialpose", "max_forks_repo_head_hexsha": "e620fc208f573820ade6a6fe321731d0f3eb082d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2019-11-04T21:38:10.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T20:41:11.000Z", "avg_line_length": 29.7770562771, "max_line_length": 187, "alphanum_fraction": 0.5750527004, "num_tokens": 5386, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577680904463333, "lm_q2_score": 0.5813030906443134, "lm_q1q2_score": 0.4986232420325245}} {"text": "\n#include \"mex.h\"\n#include \n#include \"re3q3/re3q3.h\"\n\nvoid printUsage() {\n\tmexPrintf(\"[x] = re3q3(C);\\n\");\n\tmexPrintf(\" coefficient order is [ x^2, xy, xz, y^2, yz, z^2, x, y, z, 1.0 ]\\n\");\n}\n\nvoid mexFunction(int nlhs,mxArray *plhs[], int nrhs, const mxArray *prhs[]) {\n\n\tif (nrhs != 1) {\n\t\tprintUsage();\n\t\tmexErrMsgTxt(\"Please, specify 3 x 10N coefficient matrix\");\n\t}\n\tif (nlhs != 1) {\n\t\tprintUsage();\n\t\tmexErrMsgTxt(\"Require one output argument.\");\n\t}\n\t\n\tif ((mxGetM(prhs[0]) != 3) || (mxGetN(prhs[0]) % 10 != 0)) {\n\t\tprintUsage();\n\t\tmexErrMsgTxt(\"One input 3 x 10N matrix is required.\");\n\t}\n\n\tint n_instances = mxGetN(prhs[0]) / 10;\n\t\n\tdouble *data = mxGetPr(prhs[0]);\n\n\tEigen::Matrix coeffs;\n\tEigen::Matrix solutions;\n\n\tif (n_instances == 1) {\n\t\t// we are solving a single instance, output is 3xNsols\n\t\tcoeffs = Eigen::Map>(data);\n\n\t\tint n_sols = re3q3::re3q3(coeffs, &solutions);\n\t\tplhs[0] = mxCreateDoubleMatrix(3, n_sols, mxREAL);\n\n\t\tEigen::Map output_matrix = Eigen::Map(mxGetPr(plhs[0]), 3, n_sols);\n\t\toutput_matrix = solutions.block(0, 0, 3, n_sols);\n\t} else {\n\t\t// we are solving multiple instances, output is 3x8N\n\t\tplhs[0] = mxCreateDoubleMatrix(3, 8 * n_instances, mxREAL);\n\t\tdouble *output = mxGetPr(plhs[0]);\n\n\t\tEigen::Map output_matrix = Eigen::Map(mxGetPr(plhs[0]), 3, 8*n_instances);\n\t\toutput_matrix.setZero();\n\n\t\tfor (int i = 0; i < n_instances; i++) {\n\t\t\tcoeffs = Eigen::Map>(data + 30 * i);\n\t\t\tsolutions.setZero();\n\t\t\tint n_sols = re3q3::re3q3(coeffs, &solutions);\n\t\t\toutput_matrix.block(0, i * 8, 3, n_sols) = solutions.block(0,0,3,n_sols);\n\t\t}\n\t}\n}\n", "meta": {"hexsha": "ac7c3ccac9aa9a081e4cd6874208159bc600b8c7", "size": 1746, "ext": "cc", "lang": "C++", "max_stars_repo_path": "re3q3_mex.cc", "max_stars_repo_name": "vlarsson/re3q3", "max_stars_repo_head_hexsha": "ab03d271f0a30f516f052d750773b0277898751f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2020-03-26T09:30:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-06T10:14:01.000Z", "max_issues_repo_path": "re3q3_mex.cc", "max_issues_repo_name": "vlarsson/re3q3", "max_issues_repo_head_hexsha": "ab03d271f0a30f516f052d750773b0277898751f", "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": "re3q3_mex.cc", "max_forks_repo_name": "vlarsson/re3q3", "max_forks_repo_head_hexsha": "ab03d271f0a30f516f052d750773b0277898751f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-07-18T06:19:02.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-18T06:19:02.000Z", "avg_line_length": 29.593220339, "max_line_length": 110, "alphanum_fraction": 0.6466208477, "num_tokens": 641, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7341195152660688, "lm_q2_score": 0.679178692681616, "lm_q1q2_score": 0.49859833265047027}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \n#include \n#include \n\ntypedef CGAL::Simple_cartesian Kernel;\ntypedef Kernel::Point_3 Point;\ntypedef Kernel::Vector_3 Vector;\ntypedef CGAL::Polyhedron_3 Polyhedron;\ntypedef boost::graph_traits::vertex_descriptor vertex_descriptor;\n\ntypedef CGAL::Mean_curvature_flow_skeletonization Mean_curvature_skeleton;\ntypedef Mean_curvature_skeleton::Skeleton Skeleton;\ntypedef boost::graph_traits::vertex_descriptor vertex_desc;\ntypedef boost::graph_traits::edge_descriptor edge_desc;\n\n// The input of the skeletonization algorithm must be a pure triangular closed\n// mesh and has only one component.\nbool is_mesh_valid(Polyhedron& pMesh)\n{\n if (!pMesh.is_closed())\n {\n std::cerr << \"The mesh is not closed.\";\n return false;\n }\n if (!pMesh.is_pure_triangle())\n {\n std::cerr << \"The mesh is not a pure triangle mesh.\";\n return false;\n }\n\n // the algorithm is only applicable on a mesh\n // that has only one connected component\n std::size_t num_component;\n CGAL::Counting_output_iterator output_it(&num_component);\n CGAL::internal::corefinement::extract_connected_components(pMesh, output_it);\n ++output_it;\n if (num_component != 1)\n {\n std::cerr << \"The mesh is not a single closed mesh. It has \"\n << num_component << \" components.\";\n return false;\n }\n return true;\n}\n\nint main()\n{\n Polyhedron mesh;\n std::ifstream input(\"data/elephant.off\");\n\n if ( !input || !(input >> mesh) || mesh.empty() ) {\n std::cerr << \"Cannot open data/elephant.off\" << std::endl;\n return EXIT_FAILURE;\n }\n if (!is_mesh_valid(mesh)) {\n return EXIT_FAILURE;\n }\n\n Skeleton skeleton;\n\n CGAL::extract_mean_curvature_flow_skeleton(mesh, skeleton);\n\n if (num_vertices(skeleton) == 0)\n {\n std::cerr << \"The number of skeletal points is zero!\\n\";\n return EXIT_FAILURE;\n }\n\n// check all vertices are seen exactly once\n{\n std::set visited;\n BOOST_FOREACH(vertex_desc v, vertices(skeleton))\n {\n BOOST_FOREACH(vertex_descriptor vd, skeleton[v].vertices)\n if (!visited.insert(vd).second)\n {\n std::cerr << \"A vertex was seen twice!\\n\";\n return EXIT_FAILURE;\n }\n }\n\n BOOST_FOREACH(vertex_descriptor vd, vertices(mesh))\n {\n if (!visited.count(vd))\n {\n std::cerr << \"A vertex was not seen!\\n\";\n return EXIT_FAILURE;\n }\n }\n}\n\n// check the skeleton is connected\n{\n std::queue qu;\n std::set visited;\n\n qu.push(*vertices(skeleton).first);\n visited.insert(qu.back());\n\n while (!qu.empty())\n {\n vertex_desc cur = qu.front();\n qu.pop();\n\n BOOST_FOREACH(edge_desc ed, in_edges(cur, skeleton))\n {\n vertex_desc next = source(ed, skeleton);\n if (visited.insert(next).second)\n qu.push(next);\n }\n }\n\n BOOST_FOREACH(vertex_desc vd, vertices(skeleton))\n {\n if (!visited.count(vd))\n {\n std::cerr << \"Skeleton curve is not fully connected!\\n\";\n return EXIT_FAILURE;\n }\n }\n}\n std::cout << \"Pass connectivity test.\\n\";\n return EXIT_SUCCESS;\n}\n\n", "meta": {"hexsha": "c6984fac8a5c1346102b93c51a82799bb26a38f7", "size": 3679, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "graphics/cgal/Surface_mesh_skeletonization/test/Surface_mesh_skeletonization/skeleton_connectivity_test.cpp", "max_stars_repo_name": "hlzz/dotfiles", "max_stars_repo_head_hexsha": "0591f71230c919c827ba569099eb3b75897e163e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2016-03-30T14:31:52.000Z", "max_stars_repo_stars_event_max_datetime": "2019-02-02T05:01:32.000Z", "max_issues_repo_path": "graphics/cgal/Surface_mesh_skeletonization/test/Surface_mesh_skeletonization/skeleton_connectivity_test.cpp", "max_issues_repo_name": "hlzz/dotfiles", "max_issues_repo_head_hexsha": "0591f71230c919c827ba569099eb3b75897e163e", "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": "graphics/cgal/Surface_mesh_skeletonization/test/Surface_mesh_skeletonization/skeleton_connectivity_test.cpp", "max_forks_repo_name": "hlzz/dotfiles", "max_forks_repo_head_hexsha": "0591f71230c919c827ba569099eb3b75897e163e", "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": 27.0514705882, "max_line_length": 93, "alphanum_fraction": 0.6605055722, "num_tokens": 897, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624688140728, "lm_q2_score": 0.6370307875894138, "lm_q1q2_score": 0.49858008892530375}} {"text": "/******************************************************\n Author : shipeng_liu \n Email : 1196075299@qq.com\n Description: Adaptive dynamic programming \n******************************************************/\n#include \n#include\n#include \n#include \n#include \n#include \"rambot_controller/src/controller/adp_learning/critic_network.cpp\"\nusing namespace std;\n\n/****************************************************************** \n Action Network\n Input: S, diff_s\n number of hidden_layer: 1\n number of active_function: hidden_number\n output: steer_cmd\n parameter_layer1: parameters from input to hidden_layer\n parameter_layer2: parameters from hidden_layer to output\n******************************************************************/\n\nclass action_network {\n\n private:\n\n double learning_rate = 0.00001 ; //learning rate\n double reward_count = 1;\n Eigen::MatrixXd parameter_layer1;\n Eigen::MatrixXd parameter_layer2;\n Eigen::MatrixXd input_variable;\n Eigen::MatrixXd hidden_layer;\n Eigen::MatrixXd p_hidden_layer;\n double output;\n int hidden_number;\n double deriva_J_u;\n static double active_function(double input) {\n // 1 - exp( - qi(t) ) / 1 + exp( - qi(t) ) )\n double ret = std::exp(- input);\n double tmp = (2)/(1 + ret) - 1;\n return tmp;\n }\n\n\n public:\n\n action_network() \n {\n hidden_number = 4;\n init();\n }\n\n void init()\n {\n parameter_layer1 = Eigen::MatrixXd::Random(2, hidden_number);\n parameter_layer2 = Eigen::MatrixXd::Random(hidden_number, 1);\n \n hidden_layer = Eigen::MatrixXd::Random(1, hidden_number);\n p_hidden_layer = Eigen::MatrixXd::Random(1, hidden_number);\n input_variable = Eigen::MatrixXd::Random(1,2);\n output = 0;\n\n }\n\n double output_cmd(double s, double diff_s)\n {\n input_variable(0,0) = s;\n input_variable(0,1) = diff_s;\n //cout << parameter_layer1 << endl;\n //cout << parameter_layer2 << endl;\n hidden_layer = input_variable * parameter_layer1;\n \n for (int i = 0; i < hidden_number; i++)\n {\n p_hidden_layer(0,i) = active_function(hidden_layer(0,i));\n // limit the p_Hidden_layer\n if (p_hidden_layer(0,i) < 0.000001 && p_hidden_layer(0,i) > 0 )\n p_hidden_layer(0,i) = 0.000001;\n else if (p_hidden_layer(0,i) > -0.000001 && p_hidden_layer(0,i) < 0)\n p_hidden_layer(0,i) = - 0.000001;\n }\n Eigen::MatrixXd test = p_hidden_layer * parameter_layer2;\n output = test(0,0);\n output = active_function(output);\n return output;\n }\n\n void update_weight(double J_cost, critic_network *critic_network)\n {\n \n \n double reference_signal = 0;\n double eat = J_cost - reference_signal;\n cout << \"\\naction_network_information:\\n\";\n cout << left << setw(20) << \"[ refer: \" << right\n << setw(20) << reference_signal << \"]\" << endl;\n cout << left << setw(20) << \"[ J_cost: \" << right\n << setw(20) << J_cost << \"]\" << endl;\n cout << left << setw(20) << \"[ eat: \" << right\n << setw(20) << eat << \"]\" << endl;\n cout << left << setw(20) << \"[ p_hidden_layer: \" << right\n << setw(20) << p_hidden_layer << \"]\" << endl;\n cout << \"[ p_hidden_layer: \" << endl;\n cout << p_hidden_layer << endl;\n \n // cout << \"[ parameter_layer1: \" << endl;\n // cout << parameter_layer1 << endl;\n \n // cout << \"[ parameter_layer2: \" << endl;\n // cout << parameter_layer2 << endl;\n \n \n // compute the derivative of J to U\n for (int l = 0; l < 4; l++)\n {\n deriva_J_u += ( critic_network->return_parameter_layer2()(l,0) ) * 0.5 * (1 - pow(critic_network->return_p_hidden_layer()(0,l),2)) * critic_network->return_parameter_layer1()(2,l);\n }\n for (int j = 0; j < hidden_number; j++)\n {\n //compute the parameter_layer1\n for (int k = 0; k < 2; k++)\n {\n \n double derivative_1 = reward_count * eat * 0.5 * (1-pow(output,2)) * parameter_layer2(j,0) * 0.5 * (1 - pow(p_hidden_layer(0,j),2)) * input_variable(0,k) * deriva_J_u;\n double delta_weight1 = learning_rate * (- derivative_1);\n \n parameter_layer1(k,j) += delta_weight1; \n }\n\n // compute the parameter_layer2 \n \n double derivative = reward_count * eat * 0.5 * (1-pow(output,2)) *(p_hidden_layer(0,j)) * deriva_J_u;\n \n double delta_weight = learning_rate * (- derivative);\n parameter_layer2(j,0) += delta_weight;\n\n }\n \n }\n};\n \n ", "meta": {"hexsha": "76ee7a787c1872d858cb59399894f23579be8370", "size": 4889, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/controller/src/controller/adp_learning/action_network.cpp", "max_stars_repo_name": "TJ-Work/CVSC", "max_stars_repo_head_hexsha": "6850bcffe765a6586dc5a81900206398be6dc1f5", "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/controller/src/controller/adp_learning/action_network.cpp", "max_issues_repo_name": "TJ-Work/CVSC", "max_issues_repo_head_hexsha": "6850bcffe765a6586dc5a81900206398be6dc1f5", "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/controller/src/controller/adp_learning/action_network.cpp", "max_forks_repo_name": "TJ-Work/CVSC", "max_forks_repo_head_hexsha": "6850bcffe765a6586dc5a81900206398be6dc1f5", "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.1888111888, "max_line_length": 192, "alphanum_fraction": 0.5313970137, "num_tokens": 1187, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970748488297, "lm_q2_score": 0.5660185351961015, "lm_q1q2_score": 0.4985474701109455}} {"text": "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace Eigen;\n\ntemplate \nstruct ParticleFilter{\n ParticleFilter(int number_of_particles, int states, function process, function cost,\n VectorXd &start, double std):\n number_of_particles(number_of_particles), process(process), cost(cost), start(start){\n particles.resize(number_of_particles, VectorXd(states));\n weights.resize(number_of_particles, 1.0/number_of_particles);\n costs.resize(number_of_particles,RAND_MAX);\n cumsum.resize(number_of_particles);\n indx.resize(number_of_particles);\n\n distribution = normal_distribution(0,std);\n state_length = particles.begin()->size();\n\n resample(true);\n }\n\n void step(){\n double sum_of_elems = 0.0;\n for(uint i=0;i(costs, val, index);\n winner = particles[*index];\n return val;\n }\n\n function cost;\n function process;\n\n void resample(bool all, int N = 0){\n if(all){ //resample all\n for(state &particle:particles){\n particle = start;\n for(int i=0;i indexes = sort_indexes(weights);\n for(uint i=0;i\n void minimum(vector &v, T &val, int *index ){\n *index = 0;\n val = v[0];\n for(uint i=1; i\n vector sort_indexes(const vector &v) {\n\n // initialize original index locations\n vector idx(v.size());\n iota(idx.begin(), idx.end(), 0);\n\n // sort indexes based on comparing values in v\n sort(idx.begin(), idx.end(),\n [&v](size_t i1, size_t i2) {return v[i1] > v[i2];});\n\n return idx;\n }\n\n vector particles;\n vector weights, costs;\n vector cumsum;\n vector indx;\n int number_of_particles;\n default_random_engine generator;\n normal_distribution distribution;\n int state_length;\n VectorXd start;\n};", "meta": {"hexsha": "e3fb3670439c17da1cb6778ac91f2ca5392fb855", "size": 3358, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/darkroom/ParticleFilter.hpp", "max_stars_repo_name": "Roboy/DarkRoom_rviz", "max_stars_repo_head_hexsha": "8f049218bc600d4b179303493a70bfe2389df73c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2017-07-06T15:34:19.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-04T00:22:54.000Z", "max_issues_repo_path": "include/darkroom/ParticleFilter.hpp", "max_issues_repo_name": "Roboy/DarkRoom_rviz", "max_issues_repo_head_hexsha": "8f049218bc600d4b179303493a70bfe2389df73c", "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/darkroom/ParticleFilter.hpp", "max_forks_repo_name": "Roboy/DarkRoom_rviz", "max_forks_repo_head_hexsha": "8f049218bc600d4b179303493a70bfe2389df73c", "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": 28.7008547009, "max_line_length": 120, "alphanum_fraction": 0.5652173913, "num_tokens": 767, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.810478926981208, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.4985157451378339}} {"text": "/*\n * Path-related utility functions.\n *\n * Copyright (C) 2014-2015 DubinsPathPlanner.\n * Created by David Goodman \n * Redistribution and use of this file is allowed according to the terms of the MIT license.\n * For details see the LICENSE file distributed with DubinsPathPlanner.\n */\n#include \n#include \n#include \n\n#include \n\n#include \n\n#include \n#include \n#include \n#include \n\nusing Eigen::Vector3d;\nusing Eigen::Vector2d;\n\n\n#define HEADING_TOLERANCE 1E-10 // upperbound for Euclidean metric, radius safe?\n\nnamespace dpp {\n\n/**\n * Calculate the shortest Dubins' path distance to the node. Note that all angles\n * used in this function are heading angles from 0 at the y-axis, and\n * counter-clockwise is positive. \n * @FIXME Add RLR and LRL curves. Does this fix dist > 3*r?\n */\ndouble dubinsPathLength(VehicleConfiguration &Cs, VehicleConfiguration &Ce,\n double turnRadius) {\n double r = turnRadius; // shorter name\n Vector2d Ps = Vector2d(Cs.x(), Cs.y()),\n Pe = Vector2d(Ce.x(), Ce.y());\n double Xs = Cs.m_heading,\n Xe = Ce.m_heading;\n double dist = (Ps - Pe).norm();\n\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"Given Cs=\" << Cs << \", Ce=\" << Ce << \", r=\" << r << std::endl;\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"Got dist=\" << dist << \" compared to r=\" << r << \".\" << std::endl;\n\n\n // Added tolerance to avoid numerical instability for paths with no curviture\n // TODO compute curviture as ratio w.r.t. turn radius?\n // FIXME this does not take into account the feasability of the path! \n // Should add an isReachable( func)\n if (fabs(Xs - Xe) <= HEADING_TOLERANCE) {\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"Using straight line L=\" << (Pe - Ps).norm() << \". |Xs - Xe| = \"\n << fabs(Xs - Xe) << \" <= \" << HEADING_TOLERANCE << std::endl;\n return (Pe - Ps).norm();\n }\n\n //DPP_ASSERT(dist >= 3.0 * r);\n // FIXME: return an unfeasible path macro, eg -1\n // FIXME: improve this function so that we don't have to use the dubins-curves library\n // this is needed for boustrophedon algorithm which does not care if the\n // point dist is >= 3.0 * r\n // note: Detect if the final heading is close to the opposite of the initial,\n // to allow for implementing CCC-type paths (ie. U-turns) via Dubins\n // Corollarry to theorem 1. Though this may not satisfy all cases where \n // no feasible paths exist. \"U-turn\" is either: {RLR or LRL}?\n if (dist < 3.0 * r) {\n //return DPP_MAX_EDGE_COST;\n double *q0, *q1;\n Cs.asArray(&q0);\n Ce.asArray(&q1);\n q0[2] = dpp::headingToAngle(q0[2]);\n q1[2] = dpp::headingToAngle(q1[2]);\n DubinsCurves::DubinsPath path;\n DubinsCurves::dubins_init( q0, q1, turnRadius, &path);\n double expectedLength = DubinsCurves::dubins_path_length(&path);\n return expectedLength;\n }\n //if (dist < 3.0 * r) {\n // std::domain_error(\"distance must be larger than 3*r\");\n //}\n\n // Convert headings to circular angles\n double alpha = headingToAngle(Xs),\n beta = headingToAngle(Xe);\n\n // Find circle center points for each case\n Vector3d R_rs(cos(alpha - M_PI/2.0), sin(alpha - M_PI/2.0), 0.0),\n R_ls(cos(alpha + M_PI/2.0), sin(alpha + M_PI/2.0), 0.0),\n R_re(cos(beta - M_PI/2.0), sin(beta - M_PI/2.0), 0.0),\n R_le(cos(beta + M_PI/2.0), sin(beta + M_PI/2.0), 0.0);\n\n Vector3d PC_rs(Cs.x(), Cs.y(), 0.0),\n PC_ls(Cs.x(), Cs.y(), 0.0),\n PC_re(Ce.x(), Ce.y(), 0.0),\n PC_le(Ce.x(), Ce.y(), 0.0);\n\n PC_rs = PC_rs.transpose() + r*R_rs.transpose();\n PC_ls = PC_ls.transpose() + r*R_ls.transpose();\n PC_re = PC_re.transpose() + r*R_re.transpose();\n PC_le = PC_le.transpose() + r*R_le.transpose();\n\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"PC_rs: (\" << PC_rs.x() << \",\" << PC_rs.y()\n << \",\" << PC_rs.z() << \",\" <<\").\" << std::endl;\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"PC_ls: (\" << PC_ls.x() << \",\" << PC_ls.y()\n << \",\" << PC_ls.z() << \",\" <<\").\" << std::endl;\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"PC_re: (\" << PC_re.x() << \",\" << PC_re.y()\n << \",\" << PC_re.z() << \",\" <<\").\" << std::endl;\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"PC_le: (\" << PC_le.x() << \",\" << PC_le.y()\n << \",\" << PC_le.z() << \",\" <<\").\" << std::endl;\n\n // Case I, R-S-R\n double x = headingBetween(PC_rs, PC_re);\n double L1 = (PC_rs - PC_re).norm() \n + r*wrapAngle(2.0 * M_PI + wrapAngle(x - M_PI/2.0) - wrapAngle(Xs - M_PI/2.0))\n + r*wrapAngle(2.0 * M_PI + wrapAngle(Xe - M_PI/2.0) - wrapAngle(x - M_PI/2.0));\n\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"L1: \" << L1 << \", with x=\" << x << std::endl;\n\n // Case II, R-S-L\n double ls = (PC_le - PC_rs).norm();\n x = headingBetween(PC_rs, PC_le);\n double x2 = x - M_PI/2.0 + asin(2.0*r/ls);\n double L2 = sqrt(ls*ls - 4*r*r) + r*wrapAngle(2.0*M_PI + wrapAngle(x2)\n - wrapAngle(Xs - M_PI/2.0)) + r*wrapAngle(2.0*M_PI + wrapAngle(x2 + M_PI)\n - wrapAngle(Xe + M_PI/2.0));\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"L2: \" << L2 << \" with ls=\" << ls << \", x=\" << x << \", x2=\" << x2 << std::endl;\n\n // Case III, L-S-R\n ls = (PC_re - PC_ls).norm();\n x = headingBetween(PC_ls, PC_re);\n double ratioOA = 2.0*r/ls;\n // Bound the ratio from -1 to 1\n ratioOA = std::max (-1.0, ratioOA);\n ratioOA = std::min (1.0, ratioOA);\n DPP_ASSERT(ratioOA <= 1.0 && ratioOA >= -1.0);\n x2 = acos(ratioOA);\n double L3 = sqrt(ls*ls - 4*r*r) + r*wrapAngle(2.0*M_PI + wrapAngle(Xs + M_PI/2.0) \n - wrapAngle(x + x2)) + r*wrapAngle(2.0*M_PI + wrapAngle(Xe - M_PI/2.0)\n - wrapAngle(x + x2 - M_PI));\n\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"L3: \" << L3 << \" with ls=\" << ls << \", x=\" << x << \", x2=\"\n << x2 << std::endl;\n\n // Case IV, L-S-L\n x = headingBetween(PC_ls, PC_le);\n double L4 = (PC_ls - PC_le).norm() + r*wrapAngle(2.0*M_PI + wrapAngle(Xs + M_PI/2.0)\n - wrapAngle(x + M_PI/2.0)) + r*wrapAngle(2.0*M_PI + wrapAngle(x + M_PI/2.0)\n - wrapAngle(Xe + M_PI/2.0));\n\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"L4: \" << L4 << \", with x=\" << x << std::endl;\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"Comparing L1=\" << L1 << \" L2=\" << L2 << \" L3=\" << L3 << \" L4=\"\n << L4 << std::endl;\n\n return std::min({L1, L2, L3, L4});\n}\n\n/**\n * Finds the cost of the shortest dubins path over the given tour with headings.\n * If returnCost is true, the cost of returning back to the first node in the\n * tour will be included.\n * @param[in] G graph with nodes to tour\n * @param[in] GA attributes of the graph\n * @param[in] Tour ordered list of nodes to visit\n * @param[in] Headings for vehicle at each node\n * @param[in] turnRadius of the vehicle\n * @param[in] returnEdge whether to add a return edge back to the first node\n */\ndouble dubinsTourCost(ogdf::Graph &G, ogdf::GraphAttributes &GA,\n ogdf::List &Tour, ogdf::NodeArray &Headings,\n double turnRadius, bool returnCost) {\n ogdf::ListIterator iter;\n double cost = 0.0;\n\n if (Tour.size() < 2) {\n Logger::logWarn(DPP_LOGGER_VERBOSE_1) << \"Zero cost for an empty tour.\" << std::endl;\n return 0.0;\n }\n\n // Add the return edge if necessary\n ogdf::List modTour(Tour);\n ogdf::node lastNode = modTour.back();\n if (returnCost && lastNode != *(modTour.begin())) {\n modTour.pushBack(*(Tour.begin()));\n }\n else if (!returnCost && lastNode == *(modTour.begin())) {\n modTour.popBack();\n }\n\n int m = modTour.size() - 1;\n int i = 0; // edge index\n for ( iter = modTour.begin(); (i < m && iter != modTour.end()); iter++ ) {\n ogdf::node u = *iter, v = *(iter.succ());\n\n VehicleConfiguration Cu(GA.x(u), GA.y(u), Headings(u)),\n Cv(GA.x(v), GA.y(v), Headings(v));\n cost += dubinsPathLength(Cu, Cv, turnRadius);\n i++;\n \n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"Found cost \" << cost << \" from node \"\n << GA.idNode(u) << \"->\" << GA.idNode(v) << \", where headings \"\n << GA.idNode(u) << \": \" << Headings(u) << \", \" << GA.idNode(v) << \": \"\n << Headings(v) << std::endl;\n }\n Logger::logDebug(DPP_LOGGER_VERBOSE_2) << \"Found total cost \"\n << cost << \" for tour.\" << std::endl;\n\n return cost;\n}\n\n/**\n * Adds weighted edges to the graph with the cost of the shortest dubins path\n * between each node in the tour. If returnEdge is true, an edge returning to the\n * origin is added. Added edges are saved into the list of edges.\n * @param[in] G graph with nodes to tour\n * @param[in] GA attributes of the graph\n * @param[in] Tour ordered list of nodes to visit\n * @param[in] Headings for vehicle at each node\n * @param[in] turnRadius of the vehicle\n * @param[out] Edges ordered list of edges to build\n * @param[in] returnEdge whether to add a return edge back to the first node\n */\ndouble createDubinsTourEdges(ogdf::Graph &G, ogdf::GraphAttributes &GA,\n ogdf::List &Tour, ogdf::NodeArray &Headings,\n double turnRadius, ogdf::List &Edges, bool returnEdge) {\n ogdf::ListIterator iter;\n double total_cost = 0.0;\n\n if (Tour.size() < 2) return 0.0;\n DPP_ASSERT(G.numberOfEdges() < 1);\n // std::range_error(\"Cannot have existing edges in graph\");\n //}\n\n // Add the return edge if necessary\n ogdf::List modTour(Tour);\n ogdf::node lastNode = modTour.back();\n if (returnEdge && lastNode != *(modTour.begin())) {\n modTour.pushBack(*(Tour.begin()));\n }\n else if (!returnEdge && lastNode == *(modTour.begin())) {\n modTour.popBack();\n }\n \n int m = modTour.size() - 1;\n int i = 0; // edge index\n for ( iter = modTour.begin(); (i < m && iter != modTour.end()); iter++ ) {\n ogdf::node u = *iter, v = *(iter.succ());\n\n VehicleConfiguration Cu(GA.x(u), GA.y(u), Headings(u)),\n Cv(GA.x(v), GA.y(v), Headings(v));\n double cost = dubinsPathLength(Cu, Cv, turnRadius);\n\n Logger::logDebug(DPP_LOGGER_VERBOSE_3) << \"Found cost \" << cost << \" from node \"\n << GA.idNode(u) << \"->\" << GA.idNode(v) << \", where headings \"\n << GA.idNode(u) << \": \" << Headings(u) << \", \" << GA.idNode(v) << \": \"\n << Headings(v) << std::endl;\n //printf(\"Found cost %0.1f from node %d->%d, where headings %d: %0.1f, %d: %0.1f\\n\",\n // cost, GA.idNode(u), GA.idNode(v), GA.idNode(u), Headings(u), GA.idNode(v), Headings(v));\n\n // Add the edge\n ogdf::edge e = G.newEdge(u,v);\n GA.doubleWeight(e) = cost;\n Edges.pushBack(e);\n total_cost += cost;\n i++;\n }\n Logger::logDebug(DPP_LOGGER_VERBOSE_2) << \"Created tour edges with total cost \"\n << total_cost << \": \" << std::endl;\n Logger::logDebug(DPP_LOGGER_VERBOSE_2) << printEdges(G, GA, Edges);\n\n return total_cost;\n}\n\n\n\n/**\n * Computes an adjacency matrix of Dubins path lengths between nodes with the\n * given headings (for ATSP).\n */\nvoid buildDubinsAdjacencyMatrix(ogdf::Graph &G, ogdf::GraphAttributes &GA, \n NodeMatrix &A, ogdf::NodeArray &Headings, double turnRadius) {\n \n ogdf::node i, j;\n forall_nodes(i, G) {\n VehicleConfiguration Ci(GA.x(i), GA.y(i), Headings(i));\n\n forall_nodes(j, G) {\n if (i == j) {\n A[i][i] = DPP_MAX_EDGE_COST;\n continue;\n }\n VehicleConfiguration Cj(GA.x(j), GA.y(j), Headings(j));\n \n double w = dubinsPathLength(Ci, Cj, turnRadius);\n A[i][j] = w;\n }\n }\n}\n\n} // namespace DPP\n\n", "meta": {"hexsha": "259c50d91080b6fd6c21baf3099aa9e47f4350f8", "size": 11966, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/dpp/basic/Path.cpp", "max_stars_repo_name": "dagoodma/dubins_coverage", "max_stars_repo_head_hexsha": "f05333b55fb2cb073bb572562726f8b711df54ad", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2017-09-28T00:56:51.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T16:02:56.000Z", "max_issues_repo_path": "src/dpp/basic/Path.cpp", "max_issues_repo_name": "dagoodma/dubins_coverage", "max_issues_repo_head_hexsha": "f05333b55fb2cb073bb572562726f8b711df54ad", "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/dpp/basic/Path.cpp", "max_forks_repo_name": "dagoodma/dubins_coverage", "max_forks_repo_head_hexsha": "f05333b55fb2cb073bb572562726f8b711df54ad", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11.0, "max_forks_repo_forks_event_min_datetime": "2016-12-16T03:32:45.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-31T06:54:03.000Z", "avg_line_length": 39.4917491749, "max_line_length": 125, "alphanum_fraction": 0.5828179843, "num_tokens": 3670, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789178257653, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.49851573950643224}} {"text": "///////////////////////////////////////////////////////////////////////////////\r\n// weighted_variance.hpp\r\n//\r\n// Copyright 2005 Daniel Egloff, Eric Niebler. Distributed under the Boost\r\n// Software License, Version 1.0. (See accompanying file\r\n// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\r\n\r\n#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_VARIANCE_HPP_EAN_28_10_2005\r\n#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_VARIANCE_HPP_EAN_28_10_2005\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\nnamespace boost { namespace accumulators\r\n{\r\n\r\nnamespace impl\r\n{\r\n //! Lazy calculation of variance of weighted samples.\r\n /*!\r\n The default implementation of the variance of weighted samples is based on the second moment\r\n \\f$\\widehat{m}_n^{(2)}\\f$ (weighted_moment<2>) and the mean\\f$ \\hat{\\mu}_n\\f$ (weighted_mean):\r\n \\f[\r\n \\hat{\\sigma}_n^2 = \\widehat{m}_n^{(2)}-\\hat{\\mu}_n^2,\r\n \\f]\r\n where \\f$n\\f$ is the number of samples.\r\n */\r\n template\r\n struct lazy_weighted_variance_impl\r\n : accumulator_base\r\n {\r\n typedef typename numeric::functional::multiplies::result_type weighted_sample;\r\n // for boost::result_of\r\n typedef typename numeric::functional::average::result_type result_type;\r\n\r\n lazy_weighted_variance_impl(dont_care) {}\r\n\r\n template\r\n result_type result(Args const &args) const\r\n {\r\n extractor const some_mean = {};\r\n result_type tmp = some_mean(args);\r\n return weighted_moment<2>(args) - tmp * tmp;\r\n }\r\n };\r\n\r\n //! Iterative calculation of variance of weighted samples.\r\n /*!\r\n Iterative calculation of variance of weighted samples:\r\n \\f[\r\n \\hat{\\sigma}_n^2 =\r\n \\frac{\\bar{w}_n - w_n}{\\bar{w}_n}\\hat{\\sigma}_{n - 1}^2\r\n + \\frac{w_n}{\\bar{w}_n - w_n}\\left(X_n - \\hat{\\mu}_n\\right)^2\r\n ,\\quad n\\ge2,\\quad\\hat{\\sigma}_0^2 = 0.\r\n \\f]\r\n where \\f$\\bar{w}_n\\f$ is the sum of the \\f$n\\f$ weights \\f$w_i\\f$ and \\f$\\hat{\\mu}_n\\f$\r\n the estimate of the mean of the weighted smaples. Note that the sample variance is not defined for\r\n \\f$n <= 1\\f$.\r\n */\r\n template\r\n struct weighted_variance_impl\r\n : accumulator_base\r\n {\r\n typedef typename numeric::functional::multiplies::result_type weighted_sample;\r\n // for boost::result_of\r\n typedef typename numeric::functional::average::result_type result_type;\r\n\r\n template\r\n weighted_variance_impl(Args const &args)\r\n : weighted_variance(numeric::average(args[sample | Sample()], numeric::one::value))\r\n {\r\n }\r\n\r\n template\r\n void operator ()(Args const &args)\r\n {\r\n std::size_t cnt = count(args);\r\n\r\n if(cnt > 1)\r\n {\r\n extractor const some_mean = {};\r\n\r\n result_type tmp = args[parameter::keyword::get()] - some_mean(args);\r\n\r\n this->weighted_variance =\r\n numeric::average(this->weighted_variance * (sum_of_weights(args) - args[weight]), sum_of_weights(args))\r\n + numeric::average(tmp * tmp * args[weight], sum_of_weights(args) - args[weight] );\r\n }\r\n }\r\n\r\n result_type result(dont_care) const\r\n {\r\n return this->weighted_variance;\r\n }\r\n\r\n private:\r\n result_type weighted_variance;\r\n };\r\n\r\n} // namespace impl\r\n\r\n///////////////////////////////////////////////////////////////////////////////\r\n// tag::weighted_variance\r\n// tag::immediate_weighted_variance\r\n//\r\nnamespace tag\r\n{\r\n struct lazy_weighted_variance\r\n : depends_on, weighted_mean>\r\n {\r\n /// INTERNAL ONLY\r\n ///\r\n typedef accumulators::impl::lazy_weighted_variance_impl impl;\r\n };\r\n\r\n struct weighted_variance\r\n : depends_on\r\n {\r\n /// INTERNAL ONLY\r\n ///\r\n typedef accumulators::impl::weighted_variance_impl impl;\r\n };\r\n}\r\n\r\n///////////////////////////////////////////////////////////////////////////////\r\n// extract::weighted_variance\r\n// extract::immediate_weighted_variance\r\n//\r\nnamespace extract\r\n{\r\n extractor const lazy_weighted_variance = {};\r\n extractor const weighted_variance = {};\r\n}\r\n\r\nusing extract::lazy_weighted_variance;\r\nusing extract::weighted_variance;\r\n\r\n// weighted_variance(lazy) -> lazy_weighted_variance\r\ntemplate<>\r\nstruct as_feature\r\n{\r\n typedef tag::lazy_weighted_variance type;\r\n};\r\n\r\n// weighted_variance(immediate) -> weighted_variance\r\ntemplate<>\r\nstruct as_feature\r\n{\r\n typedef tag::weighted_variance type;\r\n};\r\n\r\n////////////////////////////////////////////////////////////////////////////\r\n//// droppable_accumulator\r\n//// need to specialize droppable lazy weighted_variance to cache the result at the\r\n//// point the accumulator is dropped.\r\n///// INTERNAL ONLY\r\n/////\r\n//template\r\n//struct droppable_accumulator >\r\n// : droppable_accumulator_base<\r\n// with_cached_result >\r\n// >\r\n//{\r\n// template\r\n// droppable_accumulator(Args const &args)\r\n// : droppable_accumulator::base(args)\r\n// {\r\n// }\r\n//};\r\n\r\n}} // namespace boost::accumulators\r\n\r\n#endif\r\n", "meta": {"hexsha": "41b4fb286266c68ef91185bd0343b24dd9099c28", "size": 6634, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "windows/include/boost/accumulators/statistics/weighted_variance.hpp", "max_stars_repo_name": "jaredhoberock/gotham", "max_stars_repo_head_hexsha": "e3551cc355646530574d086d7cc2b82e41e8f798", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2015-12-29T07:21:01.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-29T10:47:38.000Z", "max_issues_repo_path": "windows/include/boost/accumulators/statistics/weighted_variance.hpp", "max_issues_repo_name": "jaredhoberock/gotham", "max_issues_repo_head_hexsha": "e3551cc355646530574d086d7cc2b82e41e8f798", "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": "windows/include/boost/accumulators/statistics/weighted_variance.hpp", "max_forks_repo_name": "jaredhoberock/gotham", "max_forks_repo_head_hexsha": "e3551cc355646530574d086d7cc2b82e41e8f798", "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": 36.0543478261, "max_line_length": 124, "alphanum_fraction": 0.6276756105, "num_tokens": 1461, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789086703224, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.49851573387503045}} {"text": "#include \r\n#include \r\n\r\nusing namespace Rcpp;\r\n\r\n// [[Rcpp::plugins(\"cpp11\")]]\r\n// [[Rcpp::depends(BH)]]\r\n\r\n//'Estep in girt.\r\n//'\r\n//'@param xall Item response matrix.\r\n//'@param t0 item parameter vector\r\n//'@param Xm node of theta dist.\r\n//'@param Wm weight of theta dist.\r\n//'@param group a vector.\r\n//'@param ind a design matrix for group.\r\n//'@param resp a design matrix for person.\r\n//'@param D factor constant.\r\n//'@param MLL a vector\r\n//'@export\r\n// [[Rcpp::export]]\r\n\r\nList Estep_irt(\r\n IntegerMatrix xall,\r\n NumericMatrix t0, // a, b, c\r\n NumericVector Xm,\r\n NumericMatrix Wm,\r\n IntegerVector group,\r\n IntegerMatrix ind, // design matrix\r\n IntegerMatrix resp, // design matrix\r\n double D,\r\n NumericVector MLL\r\n){\r\n\r\n int nj = xall.ncol();// item n\r\n int ni = xall.nrow(); // subject n\r\n int N = Xm.length(); // node n\r\n int ng = max(group); // group n\r\n\r\n double a,b,c,t,tt,u,x;\r\n int g,i,m,j;\r\n\r\n boost::multi_array Lim (boost::extents[ng][ni][N]);\r\n boost::multi_array Gim (boost::extents[ng][ni][N]);\r\n boost::multi_array Njm (boost::extents[ng][nj][N]);\r\n boost::multi_array rjm (boost::extents[ng][nj][N]);\r\n\r\n for(g=0; g(f)){\r\n // 対数尤度の計算に失敗したら，計算を中止する。\r\n stop(\"Can't calculate marginal log likelihood.\");\r\n }\r\n\r\n //Rcout<<\"expected frequency of subjects in each nodes calculation.\\n\";\r\n double k,kk;\r\n for(int g=0; g\n#include \n#include \n#include \n#include \n#include \n#include \n\nvoid check_inverse(expected_result const& result, expected_result const& expected, expected_result const& reference, double reference_error)\n{\n check_one(result.lon, expected.lon, reference.lon, reference_error);\n check_one(result.lat, expected.lat, reference.lat, reference_error);\n}\n\nvoid test_all(expected_results const& results)\n{\n double const d2r = bg::math::d2r();\n double const r2d = bg::math::r2d();\n\n double lona1r = results.p1.lon * d2r;\n double lata1r = results.p1.lat * d2r;\n double lona2r = results.p2.lon * d2r;\n double lata2r = results.p2.lat * d2r;\n double lonb1r = results.q1.lon * d2r;\n double latb1r = results.q1.lat * d2r;\n double lonb2r = results.q2.lon * d2r;\n double latb2r = results.q2.lat * d2r;\n\n expected_result result;\n\n // WGS84\n bg::srs::spheroid spheroid(6378137.0, 6356752.3142451793);\n\n bg::formula::gnomonic_intersection\n ::apply(lona1r, lata1r, lona2r, lata2r, lonb1r, latb1r, lonb2r, latb2r, result.lon, result.lat, spheroid);\n result.lon *= r2d;\n result.lat *= r2d;\n check_inverse(result, results.gnomonic_vincenty, results.gnomonic_karney, 0.00000001);\n\n bg::formula::gnomonic_intersection\n ::apply(lona1r, lata1r, lona2r, lata2r, lonb1r, latb1r, lonb2r, latb2r, result.lon, result.lat, spheroid);\n result.lon *= r2d;\n result.lat *= r2d;\n check_inverse(result, results.gnomonic_thomas, results.gnomonic_karney, 0.0000001);\n\n bg::formula::sjoberg_intersection\n ::apply(lona1r, lata1r, lona2r, lata2r, lonb1r, latb1r, lonb2r, latb2r, result.lon, result.lat, spheroid);\n result.lon *= r2d;\n result.lat *= r2d;\n check_inverse(result, results.sjoberg_vincenty, results.sjoberg_karney, 0.00000001);\n\n bg::formula::sjoberg_intersection\n ::apply(lona1r, lata1r, lona2r, lata2r, lonb1r, latb1r, lonb2r, latb2r, result.lon, result.lat, spheroid);\n result.lon *= r2d;\n result.lat *= r2d;\n check_inverse(result, results.sjoberg_thomas, results.sjoberg_karney, 0.0000001);\n\n bg::formula::sjoberg_intersection\n ::apply(lona1r, lata1r, lona2r, lata2r, lonb1r, latb1r, lonb2r, latb2r, result.lon, result.lat, spheroid);\n result.lon *= r2d;\n result.lat *= r2d;\n check_inverse(result, results.sjoberg_andoyer, results.sjoberg_karney, 0.0001);\n}\n\nint test_main(int, char*[])\n{\n for (size_t i = 0; i < expected_size; ++i)\n {\n test_all(expected[i]);\n }\n\n return 0;\n}\n", "meta": {"hexsha": "f0b1b49d7db8b5c6c6299f5fd2d5c92d7ef85158", "size": 3528, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/geometry/test/formulas/intersection.cpp", "max_stars_repo_name": "metux/boost", "max_stars_repo_head_hexsha": "e0157afdd519a2b14356cea62fcdac81829324cc", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2015-06-01T15:17:22.000Z", "max_stars_repo_stars_event_max_datetime": "2015-06-01T16:06:53.000Z", "max_issues_repo_path": "libs/geometry/test/formulas/intersection.cpp", "max_issues_repo_name": "metux/boost", "max_issues_repo_head_hexsha": "e0157afdd519a2b14356cea62fcdac81829324cc", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 28.0, "max_issues_repo_issues_event_min_datetime": "2016-10-16T19:42:37.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-14T21:29:48.000Z", "max_forks_repo_path": "libs/geometry/test/formulas/intersection.cpp", "max_forks_repo_name": "metux/boost", "max_forks_repo_head_hexsha": "e0157afdd519a2b14356cea62fcdac81829324cc", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2017-03-19T07:18:18.000Z", "max_forks_repo_forks_event_max_datetime": "2017-03-19T07:18:18.000Z", "avg_line_length": 40.0909090909, "max_line_length": 140, "alphanum_fraction": 0.7219387755, "num_tokens": 1117, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8519528019683106, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.4984785677583354}} {"text": "//---------------------------------------------------------------------------//\n// Copyright (c) 2020 Mikhail Komarov \n//\n// Distributed under the Boost Software License, Version 1.0\n// See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt\n//---------------------------------------------------------------------------//\n\n#ifndef BOOST_MULTIPRECISION_MODULAR_BACKENDS_INVERSE_HPP\n#define BOOST_MULTIPRECISION_MODULAR_BACKENDS_INVERSE_HPP\n\n#include \n#include \n\n#include \n\n#include \n#include \n\nnamespace nil {\n namespace crypto3 {\n namespace multiprecision {\n namespace backends {\n\n template\n constexpr Backend eval_extended_euclidean_algorithm(Backend& a, Backend& b, Backend& x, Backend& y) {\n if (eval_is_zero(a)) {\n using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;\n x = ui_type(0u);\n y = ui_type(1u);\n return b;\n }\n Backend x1, y1, tmp = b;\n eval_modulus(tmp, a);\n Backend d = eval_extended_euclidean_algorithm(tmp, a, x1, y1);\n tmp = b;\n eval_divide(tmp, a);\n eval_multiply(tmp, x1);\n x = y1;\n eval_subtract(x, tmp);\n y = x1;\n return d;\n }\n\n template\n constexpr Backend eval_inverse_extended_euclidean_algorithm(const Backend& a, const Backend& m) {\n using Backend_doubled = typename default_ops::double_precision_type::type;\n\n Backend aa = a, mm = m, x, y, g;\n using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;\n g = eval_extended_euclidean_algorithm(aa, mm, x, y);\n if (!eval_eq(g, ui_type(1u))) {\n // BOOST_THROW_EXCEPTION(std::invalid_argument(\"eval_inverse_with_gcd: no inverse element\"));\n return ui_type(0u);\n } else {\n eval_modulus(x, m);\n Backend_doubled tmp(x);\n eval_add(tmp, m);\n eval_modulus(tmp, m);\n return static_cast(tmp);\n }\n }\n\n template\n constexpr typename std::tuple_element<0, typename Backend::signed_types>::type\n eval_monty_inverse(typename std::tuple_element<0, typename Backend::signed_types>::type a) {\n using si_type = typename std::tuple_element<0, typename Backend::signed_types>::type;\n\n if (a % 2 == 0) {\n throw std::invalid_argument(\"monty_inverse only valid for odd integers\");\n }\n\n /*\n * From \"A New Algorithm for Inversion mod p^k\" by Çetin Kaya Koç\n * https://eprint.iacr.org/2017/411.pdf sections 5 and 7.\n */\n\n si_type b = 1;\n si_type r = 0;\n\n for (size_t i = 0; i != sizeof(si_type) * CHAR_BIT; ++i) {\n const si_type bi = b % 2;\n r >>= 1;\n r += bi << (sizeof(si_type) * CHAR_BIT - 1);\n\n b -= a * bi;\n b >>= 1;\n }\n\n // Now invert in addition space\n r = (~static_cast(0) - r) + 1;\n\n return r;\n }\n\n template\n constexpr void eval_monty_inverse(Backend& res, const Backend& a, const Backend& p, const Backend& k) {\n\n using default_ops::eval_abs;\n using default_ops::eval_gt;\n using default_ops::eval_modulus;\n using default_ops::eval_subtract;\n\n using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;\n Backend zero = ui_type(0u);\n Backend one = ui_type(1u);\n Backend two = ui_type(2u);\n\n /*\n * From \"A New Algorithm for Inversion mod p^k\" by Çetin Kaya Koç\n * https://eprint.iacr.org/2017/411.pdf sections 5 and 7.\n */\n Backend c, tmp;\n\n // a^(-1) mod p:\n c = eval_inverse_extended_euclidean_algorithm(a, p);\n\n Backend bi = one, bt, i = zero, k_negone = k, xi, nextp = one;\n eval_subtract(k_negone, one);\n res = zero;\n\n // ui_type kn = cpp_int(k_negone);\n\n while (!eval_eq(i, k)) {\n // xi:\n xi = bi;\n eval_multiply(xi, c);\n eval_modulus(xi, p);\n\n if (eval_get_sign(xi) < 0) {\n tmp = xi;\n eval_abs(tmp, tmp);\n eval_modulus(tmp, p);\n xi = p;\n eval_subtract(xi, tmp);\n }\n\n // bi:\n tmp = a;\n eval_multiply(tmp, xi);\n eval_subtract(bi, tmp);\n eval_divide(bi, p);\n\n // res:\n tmp = xi;\n eval_multiply(tmp, nextp);\n eval_multiply(nextp, p);\n eval_add(res, tmp);\n eval_add(i, one);\n }\n }\n\n /*\n template \n inline void bigint_shr1(typename boost::mpl::front::type x[], size_t x_size, size_t word_shift, size_t bit_shift)\n {\n typedef typename boost::mpl::front::type ui_type;\n\n const size_t top = x_size >= word_shift ? (x_size - word_shift) : 0;\n\n if (top > 0)\n copy_mem(x, x + word_shift, top);\n clear_mem(x + top, std::min(word_shift, x_size));\n\n const auto carry_mask = CT::Mask::expand(bit_shift);\n const size_t carry_shift = carry_mask.if_set_return(BOTAN_MP_WORD_BITS - bit_shift);\n\n ui_type carry = 0;\n\n for (size_t i = 0; i != top; ++i)\n {\n const ui_type w = x[top - i - 1];\n x[top - i - 1] = (w >> bit_shift) | carry;\n carry = carry_mask.if_set_return(w << carry_shift);\n }\n }\n\n template \n inline typename boost::mpl::front::type\n bigint_add2_nc( typename boost::mpl::front::type x[], size_t\n x_size, const typename boost::mpl::front::type y[], size_t y_size)\n {\n typedef typename boost::mpl::front::type ui_type;\n\n ui_type carry = 0;\n\n BOOST_ASSERT_MSG(x_size >= y_size, \"Expected sizes\");\n\n const size_t blocks = y_size - (y_size % 8);\n\n for (size_t i = 0; i != blocks; i += 8)\n carry = word8_add2(x + i, y + i, carry);\n\n for (size_t i = blocks; i != y_size; ++i)\n x[i] = word_add(x[i], y[i], &carry);\n\n for (size_t i = y_size; i != x_size; ++i)\n x[i] = word_add(x[i], 0, &carry);\n\n return carry;\n }\n\n template \n inline typename boost::mpl::front::type\n bigint_cnd_sub( typename boost::mpl::front::type cnd, typename\n boost::mpl::front::type x[], size_t x_size, const typename\n boost::mpl::front::type y[], size_t y_size)\n {\n BOOST_ASSERT_MSG(x_size >= y_size, \"Expected sizes\");\n\n typedef typename boost::mpl::front::type ui_type;\n\n const auto mask = CT::Mask::expand(cnd);\n\n ui_type carry = 0;\n\n const size_t blocks = y_size - (y_size % 8);\n ui_type z[8] = {0};\n\n for (size_t i = 0; i != blocks; i += 8)\n {\n carry = word8_sub3(z, x + i, y + i, carry);\n mask.select_n(x + i, z, x + i, 8);\n }\n\n for (size_t i = blocks; i != y_size; ++i)\n {\n z[0] = word_sub(x[i], y[i], &carry);\n x[i] = mask.select(z[0], x[i]);\n }\n\n for (size_t i = y_size; i != x_size; ++i)\n {\n z[0] = word_sub(x[i], 0, &carry);\n x[i] = mask.select(z[0], x[i]);\n }\n\n return mask.if_set_return(carry);\n }\n\n template \n inline typename boost::mpl::front::type\n bigint_cnd_add( typename boost::mpl::front::type cnd,\n typename boost::mpl::front::type x[],\n typename boost::mpl::front::type x_size,\n const typename boost::mpl::front::type y[], size_t\n y_size)\n {\n BOTAN_ASSERT(x_size >= y_size, \"Expected sizes\");\n\n typedef typename boost::mpl::front::type ui_type;\n\n const auto mask = CT::Mask::expand(cnd);\n\n ui_type carry = 0;\n\n const size_t blocks = y_size - (y_size % 8);\n ui_type z[8] = {0};\n\n for (size_t i = 0; i != blocks; i += 8)\n {\n carry = word8_add3(z, x + i, y + i, carry);\n mask.select_n(x + i, z, x + i, 8);\n }\n\n for (size_t i = blocks; i != y_size; ++i)\n {\n z[0] = word_add(x[i], y[i], &carry);\n x[i] = mask.select(z[0], x[i]);\n }\n\n for (size_t i = y_size; i != x_size; ++i)\n {\n z[0] = word_add(x[i], 0, &carry);\n x[i] = mask.select(z[0], x[i]);\n }\n\n return mask.if_set_return(carry);\n }\n\n template \n inline void bigint_cnd_abs(typename boost::mpl::front::type cnd, typename boost::mpl::front::type x[], size_t size)\n {\n typedef typename boost::mpl::front::type ui_type;\n const auto mask =\n CT::Mask::expand(cnd);\n\n ui_type carry = mask.if_set_return(1);\n for (size_t i = 0; i != size; ++i)\n {\n const ui_type z = word_add(~x[i], 0, &carry);\n x[i] = mask.select(z, x[i]);\n }\n }\n\n template \n inline void bigint_cnd_swap(typename boost::mpl::front::type cnd, typename boost::mpl::front::type x[], typename boost::mpl::front::type y[], size_t size)\n {\n typedef typename boost::mpl::front::type ui_type;\n const auto mask =\n CT::Mask::expand(cnd);\n\n for (size_t i = 0; i != size; ++i)\n {\n const ui_type a = x[i];\n const ui_type b = y[i];\n x[i] = mask.select(b, a);\n y[i] = mask.select(a, b);\n }\n }\n\n\n template \n void eval_inverse_mod_odd_modulus(Backend& res, const Backend& n, const Backend& mod)\n {\n typedef typename boost::mpl::front::type si_type;\n typedef typename boost::mpl::front::type ui_type;\n\n // Caller should assure these preconditions:\n BOOST_ASSERT(eval_gt(n, 0));\n BOOST_ASSERT(eval_gt(mod, 0));\n BOOST_ASSERT(eval_lt(n, mod));\n BOOST_ASSERT(eval_ge(mod, 3) && eval_modulus(mod, 2) == 1);*/\n\n /*\n This uses a modular inversion algorithm designed by Niels Möller\n and implemented in Nettle. The same algorithm was later also\n adapted to GMP in mpn_sec_invert.\n It can be easily implemented in a way that does not depend on\n secret branches or memory lookups, providing resistance against\n some forms of side channel attack.\n There is also a description of the algorithm in Appendix 5 of \"Fast\n Software Polynomial Multiplication on ARM Processors using the NEON Engine\"\n by Danilo Câmara, Conrado P. L. Gouvêa, Julio López, and Ricardo\n Dahab in LNCS 8182\n https://conradoplg.cryptoland.net/files/2010/12/mocrysen13.pdf\n Thanks to Niels for creating the algorithm, explaining some things\n about it, and the reference to the paper.\n */\n /*\n const size_t mod_words = mod.size();\n BOOST_ASSERT_MSG(mod_words > 0, \"Not empty\");\n\n std::vector tmp_mem(5 * mod_words);\n\n ui_type* v_w = &tmp_mem[0];\n ui_type* u_w = &tmp_mem[1 * mod_words];\n ui_type* b_w = &tmp_mem[2 * mod_words];\n ui_type* a_w = &tmp_mem[3 * mod_words];\n ui_type* mp1o2 = &tmp_mem[4 * mod_words];\n\n // ct::poison(tmp_mem.data(), tmp_mem.size());\n\n copy_mem(a_w, n.data(), std::min(n.size(), mod_words));\n copy_mem(b_w, mod.data(), std::min(mod.size(), mod_words));\n u_w[0] = 1;\n // v_w = 0\n\n // compute (mod + 1) / 2 which [because mod is odd] is equal to\n // (mod / 2) + 1\n copy_mem(mp1o2, mod.data(), std::min(mod.size(), mod_words));\n bigint_shr1(mp1o2, mod_words, 0, 1);\n ui_type carry = bigint_add2_nc(mp1o2, mod_words, u_w, 1);\n BOOST_ASSERT(carry == 0);\n\n // Only n.bits() + mod.bits() iterations are required, but avoid leaking the size of\n n const size_t execs = 2 * eval_msb(mod);\n\n for (size_t i = 0; i != execs; ++i)\n {\n const ui_type odd_a = a_w[0] & 1;\n\n //if(odd_a) a -= b\n ui_type underflow = bigint_cnd_sub(odd_a, a_w, b_w, mod_words);\n\n //if(underflow) { b -= a; a = abs(a); swap(u, v); }\n bigint_cnd_add(underflow, b_w, a_w, mod_words);\n bigint_cnd_abs(underflow, a_w, mod_words);\n bigint_cnd_swap(underflow, u_w, v_w, mod_words);\n\n // a >>= 1\n bigint_shr1(a_w, mod_words, 0, 1);\n\n //if(odd_a) u -= v;\n ui_type borrow = bigint_cnd_sub(odd_a, u_w, v_w, mod_words);\n\n // if(borrow) u += p\n bigint_cnd_add(borrow, u_w, mod.data(), mod_words);\n\n const ui_type odd_u = u_w[0] & 1;\n\n // u >>= 1\n bigint_shr1(u_w, mod_words, 0, 1);\n\n //if(odd_u) u += mp1o2;\n bigint_cnd_add(odd_u, u_w, mp1o2, mod_words);\n }\n\n auto a_is_0 = CT::Mask::set();\n for (size_t i = 0; i != mod_words; ++i)\n a_is_0 &= CT::Mask::is_zero(a_w[i]);\n\n auto b_is_1 = CT::Mask::is_equal(b_w[0], 1);\n for (size_t i = 1; i != mod_words; ++i)\n b_is_1 &= CT::Mask::is_zero(b_w[i]);\n\n BOOST_ASSERT_MSG(a_is_0.is_set(), \"A is zero\");\n\n // if b != 1 then gcd(n,mod) > 1 and inverse does not exist\n // in which case zero out the result to indicate this\n (~b_is_1).if_set_zero_out(v_w, mod_words);*/\n\n /*\n * We've placed the result in the lowest words of the temp buffer.\n * So just clear out the other values and then give that buffer to a\n * BigInt.\n */\n /*\n clear_mem(&tmp_mem[mod_words], 4 * mod_words);\n\n CT::unpoison(tmp_mem.data(), tmp_mem.size());\n\n Backend r;\n r.swap_reg(tmp_mem);\n return r;\n }*/\n\n /*\n template \n void inverse_mod_odd_modulus(number& res,\n const number& n,\n const number& mod)\n {\n eval_inverse_mod_odd_modulus(res.backend(), n.backend(), mod.backend());\n }\n */\n\n /*\n template \n std::size_t eval_almost_montgomery_inverse(Backend& result, const Backend& a,\n const Backend& p)\n {\n size_t k = 0;\n\n Backend u = p, v = a, r = 0, s = 1;\n\n while (eval_gt(v, 0))\n {\n if (eval_integer_modulus(u, 2) == 0)\n {\n eval_right_shift(u, 1);\n eval_left_shift(s, 1);\n }\n else if (eval_integer_modulus(v, 2) == 0)\n {\n eval_right_shift(v, 1);\n eval_left_shift(r, 1);\n }\n else if (eval_gt(u, v))\n {\n eval_subtract(u, v);\n eval_right_shift(u, 1);\n eval_add(r, s);\n eval_left_shift(s, 1);\n }\n else\n {\n eval_subtract(v, u);\n eval_right_shift(v, 1);\n eval_add(s, r);\n eval_left_shift(r, 1);\n }\n\n k++;\n }\n\n if (!eval_gt(p, r))\n {\n eval_subtract(r, p);\n }\n\n result = p;\n\n eval_subtract(result, r);\n\n return k;\n }\n */\n\n /*\n template \n std::size_t almost_montgomery_inverse(number& result,\n const number& a,\n const number& p)\n {\n return eval_almost_montgomery_inverse(result.backend(), a.backend(), p.backend());\n }\n */\n\n /*\n template \n Backend eval_normalized_montgomery_inverse(const Backend& a, const Backend& p)\n {\n Backend r;\n std::size_t k = eval_almost_montgomery_inverse(r, a, p);\n\n for (std::size_t i = 0; i != k; ++i)\n {\n if (eval_integer_modulus(p, 2) == 1)\n {\n eval_add(r, p);\n }\n eval_right_shift(r, 1);\n }\n\n return r;\n }\n */\n\n /*\n template \n number normalized_montgomery_inverse(\n const number& a,\n const number& p)\n {\n return number(\n evaL_normalized_montgomery_inverse(a.backned(), p.backend()));\n }\n */\n\n /*\n template \n Backend eval_inverse_mod_pow2(Backend& a1, size_t k)\n {\n typedef typename boost::mpl::front::type ui_type;*/\n /*\n * From \"A New Algorithm for Inversion mod p^k\" by Çetin Kaya Koç\n * https://eprint.iacr.org/2017/411.pdf sections 5 and 7.\n */\n /*\n if (eval_integer_modulus(a1, 2) == 0)\n return 0;\n\n Backend a = a1;\n eval_bit_set(a, k);\n\n Backend b = 1, X = 0, newb;\n\n const std::size_t a_words = a.sig_words();\n\n X.grow_to(round_up(k, sizeof(ui_type) * CHAR_BIT) / sizeof(ui_type) * CHAR_BIT);\n b.grow_to(a_words);\n */\n /*\n Hide the exact value of k. k is anyway known to word length\n granularity because of the length of a, so no point in doing more\n than this.\n */\n /*\n\n const std::size_t iter = round_up(k, sizeof(ui_type) * CHAR_BIT);\n\n for (std::size_t i = 0; i != iter; ++i)\n {\n const bool b0 = eval_bit_test(b, 0);\n X.conditionally_set_bit(i, b0);\n newb = b;\n eval_subtract(newb, a);\n b.ct_cond_assign(b0, newb);\n eval_right_shift(b, 1);\n }\n eval_bit_set(X, k);\n X.const_time_unpoison();\n return X;\n }\n */\n\n /*\n template \n number inverse_mod_pow2(\n const number& a1, size_t k)\n {\n return number(\n eval_inverse_mod_pow2(a1.backend(), k.backend()));\n }\n */\n\n /*\n template \n Backend eval_inverse_mod(Backend& res, const Backend& n, const Backend& mod)\n {\n if (eval_is_zero(mod))\n {\n BOOST_THROW_EXCEPTION(\n std::invalid_argument(\"eval_inverse_mod: mod must be non zero\"));\n }\n if ((eval_get_sign(mod) < 0) || (eval_get_sign(n) < 0))\n {\n BOOST_THROW_EXCEPTION(\n std::invalid_argument(\"eval_inverse_mod: arguments must be non-negative\"));\n }\n if (eval_is_zero(n) || (eval_integer_modulus(n, 2) == 0 && eval_integer_modulus(mod,\n 2) == 0))\n {\n return 0;\n }\n if (eval_integer_modulus(n, 2) == 1)\n {*/\n /*\n Fastpath for common case. This leaks information if n > mod\n but we don't guarantee const time behavior in that case.\n */\n /*\n if (eval_gt(mod, n))\n return eval_inverse_mod_odd_modulus(n, mod);\n else\n return eval_inverse_mod_odd_modulus(ct_modulo(n, mod), mod);\n }\n\n const std::size_t mod_lz = eval_lsb(mod);\n BOOST_ASSERT(mod_lz > 0);\n const std::size_t mod_bits = eval_msb(mod);\n BOOST_ASSERT(mod_bits > mod_lz);\n\n if (mod_lz == mod_bits - 1)\n {\n // In this case we are performing an inversion modulo 2^k\n return eval_inverse_mod_pow2(n, mod_lz);\n }*/\n\n /*\n * In this case we are performing an inversion modulo 2^k*o for\n * some k > 1 and some odd (not necessarily prime) integer.\n * Compute the inversions modulo 2^k and modulo o, then combine them\n * using CRT, which is possible because 2^k and o are relatively prime.\n */\n /*\n Backend o = mod;\n\n eval_right_shift(mod, mod_lz);\n\n Backend n_redc = ct_modulo(n, o);\n Backend inv_o = eval_inverse_mod_odd_modulus(n_redc, o);\n Backend inv_2k = eval_inverse_mod_pow2(n, mod_lz);\n\n // No modular inverse in this case:\n if (eval_is_zero(o) || eval_is_zero(inv_2k))\n return 0;\n\n Backend m2k = mod_lz;\n eval_multiply(m2k, m2k);\n // Compute the CRT parameter\n Backend c = inverse_mod_pow2(o, mod_lz);\n\n // Compute h = c*(inv_2k-inv_o) mod 2^k\n Backend h = inv_2k;\n\n eval_subtract(h, inv_o);\n eval_multiply(h, c);\n\n const bool h_neg = (eval_get_sign(h) < 0);\n\n eval_abs(h); // h.set_sign(BigInt::Positive);\n eval_bit_set(h, mod_lz);\n\n const bool h_nonzero = !eval_is_zero(h);\n\n eval_subtracr(m2k, h);\n h.ct_cond_assign(h_nonzero && h_neg, m2k);\n\n // Return result inv_o + h * o\n eval_multiply(h, o);\n eval_add(h, inv_o);\n\n return h;\n }\n */\n } // namespace backends\n } // namespace multiprecision\n } // namespace crypto3\n} // namespace nil\n\n#endif\n", "meta": {"hexsha": "7fd6918012764c416f82db47e0e413260ef343aa", "size": 35032, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "libs/multiprecision/include/nil/crypto3/multiprecision/modular/inverse.hpp", "max_stars_repo_name": "Curryrasul/knapsack-snark", "max_stars_repo_head_hexsha": "633515a13906407338a81b9874d964869ddec624", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-09-14T18:09:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-14T18:09:38.000Z", "max_issues_repo_path": "libs/multiprecision/include/nil/crypto3/multiprecision/modular/inverse.hpp", "max_issues_repo_name": "Curryrasul/knapsack-snark", "max_issues_repo_head_hexsha": "633515a13906407338a81b9874d964869ddec624", "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": "libs/multiprecision/include/nil/crypto3/multiprecision/modular/inverse.hpp", "max_forks_repo_name": "Curryrasul/knapsack-snark", "max_forks_repo_head_hexsha": "633515a13906407338a81b9874d964869ddec624", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-01-12T10:53:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-12T10:53:21.000Z", "avg_line_length": 50.7710144928, "max_line_length": 120, "alphanum_fraction": 0.3640956839, "num_tokens": 5820, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8519528019683105, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.49847856775833527}} {"text": "/* Greg Anderson\n *\n * Wrapper classes for Apron abstractions.\n */\n\n#ifndef _ABSTRACT_H_\n#define _ABSTRACT_H_\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\nclass ArithExpr {\n private:\n ap_texpr0_t* expr;\n\n public:\n ArithExpr();\n ArithExpr(double constant);\n ArithExpr(int ind);\n ArithExpr(double lower, double upper);\n ArithExpr(ap_texpr0_t* expr);\n ArithExpr(const ArithExpr& other);\n ArithExpr(ArithExpr&& other);\n ArithExpr(const std::string& str);\n ~ArithExpr();\n ArithExpr& operator=(const ArithExpr& other);\n ArithExpr& operator=(ArithExpr&& other);\n ArithExpr negate() const;\n ArithExpr operator+(const ArithExpr& other) const;\n ArithExpr operator-(const ArithExpr& other) const;\n ArithExpr operator*(const ArithExpr& other) const;\n ArithExpr operator/(const ArithExpr& other) const;\n // Be careful about the precedence of ^. C++ uses this operator for XOR so\n // it has much lower precedence than you would expect for a power operator.\n ArithExpr operator^(int power) const;\n\n inline ap_texpr0_t* get_texpr() const {\n return expr;\n }\n};\n\n/**\n * A set of linear constraints. A point x satisfies these constraints if\n * `weights * x <= biases`.\n */\nclass LinCons {\n public:\n Eigen::MatrixXd weights;\n Eigen::VectorXd biases;\n LinCons();\n LinCons(const Eigen::MatrixXd& ws, const Eigen::VectorXd& bs);\n double distance_from(const Eigen::VectorXd& x) const;\n};\n\nenum class AbstractDomain { ZONOTOPE, INTERVAL, POLYHEDRA };\n\n/**\n * An abstract value over some underlying Apron value. This is just a\n * convenient wrapper class around Apron values.\n */\nclass AbstractVal {\n protected:\n ap_manager_t* man;\n ap_abstract0_t* value;\n virtual std::unique_ptr make_new(ap_abstract0_t* a) const;\n AbstractDomain domain;\n\n public:\n AbstractVal();\n AbstractVal(ap_manager_t* man, ap_abstract0_t* v);\n // Construct a new abstract value in the given domain subject to the\n // set of linear constraints a x <= b\n AbstractVal(AbstractDomain dom, const std::vector& a,\n const std::vector& b);\n AbstractVal(AbstractDomain dom, const LinCons& lc);\n\n // Construct a new abstract value in the given domain from the given\n // interval\n AbstractVal(AbstractDomain dom, const Eigen::VectorXd& lowers,\n const Eigen::VectorXd& uppers);\n AbstractVal(const AbstractVal& other);\n AbstractVal(AbstractVal&& other);\n virtual ~AbstractVal();\n AbstractVal& operator=(const AbstractVal& other) = delete;\n AbstractVal& operator=(AbstractVal&& other) = delete;\n\n inline ap_manager_t* get_manager() const {\n return man;\n }\n\n inline ap_abstract0_t* get_value() const {\n return value;\n }\n\n inline AbstractDomain get_domain() const {\n return domain;\n }\n\n std::unique_ptr add_trailing_dimensions(int n) const;\n std::unique_ptr add_leading_dimensions(int n) const;\n std::unique_ptr remove_trailing_dimensions(int n) const;\n\n /**\n * Meet this value with the linear constraints a x <= b.\n */\n virtual std::unique_ptr meet_linear_constraint(\n const Eigen::MatrixXd& a,\n const Eigen::VectorXd& b) const;\n\n /**\n * Perform a specific affine transformation.\n */\n virtual std::unique_ptr scalar_affine(\n const Eigen::MatrixXd& w,\n const Eigen::VectorXd& b) const;\n\n /**\n * Perform an abstract transformation where each coefficient is an interval.\n */\n virtual std::unique_ptr interval_affine(\n const Eigen::MatrixXd& wl,\n const Eigen::MatrixXd& wu,\n const Eigen::VectorXd& bl,\n const Eigen::VectorXd& bu) const;\n\n /**\n * A relu is computed as follows: for each dimension i, compute\n * x_l = meet(x, x_i < 0) and x_u = meet(x, x_i >= 0). Compute\n * x'_l = x_l[x_i <- 0]. Let x = join(x'_l, x_u).\n */\n virtual std::unique_ptr relu() const;\n\n virtual std::unique_ptr join(const AbstractVal& other) const;\n\n virtual std::unique_ptr meet(const AbstractVal& other) const;\n\n virtual std::unique_ptr widen(const AbstractVal& other) const;\n\n virtual bool operator==(const AbstractVal& other) const;\n\n /**\n * Create an abstract value by adding each dimension of b to this and\n * maintain the relations among variables in b.\n */\n virtual std::unique_ptr append(const AbstractVal& b) const;\n\n virtual std::unique_ptr arith_computation(\n const std::vector& exprs) const;\n\n inline bool is_bottom() const {\n return ap_abstract0_is_bottom(man, value);\n }\n\n inline bool is_top() const {\n return ap_abstract0_is_top(man, value);\n }\n\n bool contains_point(const Eigen::VectorXd& x) const;\n bool contains(const AbstractVal& x) const;\n Eigen::VectorXd get_center() const;\n virtual Eigen::VectorXd get_contained_point() const;\n\n /**\n * Get the number of dimensions of this abstract value.\n */\n inline size_t dims() const {\n return ap_abstract0_dimension(man, value).realdim;\n }\n\n virtual std::unique_ptr clone() const;\n\n virtual std::unique_ptr bottom() const;\n\n LinCons get_lincons() const;\n\n //virtual double distance_to_point(const Eigen::VectorXd& x) const;\n void print(FILE* out) const;\n};\n\n/**\n * Powerset is used for a bounded powerset domain. It is based on Aprons\n * disjunctive domain, but applies a consolidation step after each join or\n * merge.\n */\nclass Powerset: public AbstractVal {\n private:\n size_t size;\n\n protected:\n std::unique_ptr make_new(ap_abstract0_t* a) const override;\n\n public:\n Powerset(ap_manager_t* m, ap_abstract0_t* v, size_t s);\n Powerset(const Powerset& p);\n Powerset(AbstractDomain dom, size_t size,\n const std::vector& a,\n const std::vector& b);\n Powerset(AbstractDomain dom, size_t size, const LinCons& lc);\n Powerset(AbstractDomain dom, size_t size,\n const Eigen::VectorXd& lowers,\n const Eigen::VectorXd& uppers);\n Powerset& operator=(const Powerset& other);\n std::unique_ptr join(const AbstractVal& other) const override;\n std::unique_ptr meet(const AbstractVal& other) const override;\n std::unique_ptr arith_computation(\n const std::vector& exprs) const override;\n Eigen::VectorXd get_contained_point() const;\n std::unique_ptr clone() const override;\n std::unique_ptr bottom() const override;\n //double distance_to_point(const Eigen::VectorXd& x) const;\n};\n\n//class Managers {\n// private:\n// ap_manager_t* t1p_man;\n// ap_manager_t* box_man;\n// std::map disj_mans;\n//\n// public:\n// Managers(ap_manager_t*, ap_manager_t*);\n// ~Managers();\n// inline ap_manager_t* get_t1p_manager() const {\n// return t1p_man;\n// }\n// inline ap_manager_t* get_box_manager() const {\n// return box_man;\n// }\n// inline ap_manager_t* get_disj_manager(ap_manager_t* base) const {\n// return disj_mans.at(base);\n// }\n//};\n\n#endif\n", "meta": {"hexsha": "9e537a941e7343af29b6b671d375d2da27314d83", "size": 7511, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "abstract.hpp", "max_stars_repo_name": "gavlegoat/safe-learning", "max_stars_repo_head_hexsha": "614ad97834f1a96e6c9d7c8e6677277d9af4d816", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8.0, "max_stars_repo_stars_event_min_datetime": "2020-10-27T14:52:45.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-01T16:33:03.000Z", "max_issues_repo_path": "abstract.hpp", "max_issues_repo_name": "gavlegoat/safe-learning", "max_issues_repo_head_hexsha": "614ad97834f1a96e6c9d7c8e6677277d9af4d816", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2020-11-13T19:09:43.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-10T02:23:23.000Z", "max_forks_repo_path": "abstract.hpp", "max_forks_repo_name": "gavlegoat/safe-learning", "max_forks_repo_head_hexsha": "614ad97834f1a96e6c9d7c8e6677277d9af4d816", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-12-03T13:52:10.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-08T01:36:17.000Z", "avg_line_length": 30.6571428571, "max_line_length": 80, "alphanum_fraction": 0.6860604447, "num_tokens": 1873, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7490872243177518, "lm_q2_score": 0.665410558746814, "lm_q1q2_score": 0.49845054848337517}} {"text": "#include \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 // for boost::gcd\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\nnamespace scitbx { namespace math {\nnamespace boost_python {\n\n void wrap_basic_statistics();\n void wrap_gaussian();\n void wrap_golay();\n void wrap_minimum_covering_sphere();\n void wrap_principal_axes_of_inertia();\n void wrap_row_echelon();\n void wrap_tensor_rank_2();\n void wrap_icosahedron();\n void wrap_chebyshev_base();\n void wrap_chebyshev_polynome();\n void wrap_chebyshev_fitter();\n void wrap_chebyshev_lsq();\n void wrap_slatec();\n void wrap_line_search();\n void wrap_r3_rotation();\n void wrap_resample();\n void wrap_quadrature();\n void wrap_unimodular_generator();\n void wrap_halton();\n void wrap_least_squares_plane();\n void wrap_continued_fraction();\n void wrap_numeric_limits();\n void wrap_distributions();\n void wrap_exp_functions();\n void wrap_zernike();\n void wrap_zernike_mom();\n void wrap_2d_zernike_mom();\n void wrap_weighted_covariance();\n void wrap_dmatrix();\n void wrap_correlation();\n void wrap_interpolation();\n void wrap_tetrahedron();\n void wrap_angle_derivative();\n\nnamespace {\n\n int\n time_gcd_int_boost(\n int n)\n {\n int result = 0;\n for(int a=0;a\n boost::optional\n dihedral_angle(\n SitesType const& sites,\n bool deg)\n {\n return dihedral(sites).angle(deg);\n }\n\n mat3\n superpose_kearsley_rotation(\n af::const_ref > const& reference_sites,\n af::const_ref > const& other_sites)\n {\n return superpose::superposition<>::kearsley_rotation(\n reference_sites, other_sites);\n }\n\n mat3< double >\n euler_angles_xyz_matrix(\n const double& ax,\n const double& ay,\n const double& az )\n {\n return euler_angles::xyz_matrix( ax, ay, az );\n }\n\n vec3< double >\n euler_angles_xyz_angles(\n const mat3< double >& m,\n const double& eps = 1e-12 )\n {\n return euler_angles::xyz_angles( m, eps );\n }\n\n mat3< double >\n euler_angles_yzx_matrix(\n const double& ay,\n const double& az,\n const double& ax )\n {\n return euler_angles::yzx_matrix( ay, az, ax );\n }\n\n vec3< double >\n euler_angles_yzx_angles(\n const mat3< double >& m,\n const double& eps = 1e-12 )\n {\n return euler_angles::yzx_angles( m, eps );\n }\n\n mat3< double >\n euler_angles_zyz_matrix(\n const double& az1,\n const double& ay,\n const double& az3 )\n {\n return euler_angles::zyz_matrix( az1, ay, az3 );\n }\n\n vec3< double >\n euler_angles_zyz_angles(\n const mat3< double >& m,\n const double& eps = 1e-12 )\n {\n return euler_angles::zyz_angles( m, eps );\n }\n\n template \n struct approx_equal_relatively_wrapper\n {\n typedef math::approx_equal_relatively wt;\n typedef T arg_t;\n typedef typename wt::amplitude_type amplitude_t;\n static bool form_1(arg_t x, arg_t y, amplitude_t relative_error) {\n wt p(relative_error);\n return p(x, y);\n }\n static bool form_2(arg_t x, arg_t y, amplitude_t relative_error,\n amplitude_t near_zero_threshold)\n {\n wt p(relative_error, near_zero_threshold);\n return p(x, y);\n }\n\n static void wrap() {\n using namespace boost::python;\n def(\"approx_equal_relatively\", form_1,\n (arg(\"x\"), arg(\"y\"), arg(\"relative_error\")));\n def(\"approx_equal_relatively\", form_2,\n (arg(\"x\"), arg(\"y\"), arg(\"relative_error\"),\n arg(\"near_zero_threshold\")));\n }\n };\n\n void init_module()\n {\n using namespace boost::python;\n\n def(\"time_gcd_int_boost\", time_gcd_int_boost);\n def(\"time_gcd_long_boost\", time_gcd_long_boost);\n def(\"gcd_int_simple\", gcd_int_simple, (arg(\"a\"), arg(\"b\")));\n def(\"time_gcd_int_simple\", time_gcd_int_simple);\n def(\"gcd_long_simple\", gcd_long_simple, (arg(\"a\"), arg(\"b\")));\n def(\"time_gcd_long_simple\", time_gcd_long_simple);\n def(\"time_gcd_unsigned_long_binary\", time_gcd_unsigned_long_binary);\n def(\"gcd_long_binary\", gcd_long_binary, (arg(\"a\"), arg(\"b\")));\n def(\"time_gcd_long_binary\", time_gcd_long_binary);\n#if defined(SCITBX_MATH_GCD_USING_ASM)\n def(\"gcd_int32_asm\", gcd_int32_asm, (arg(\"a\"), arg(\"b\")));\n def(\"time_gcd_int32_asm\", time_gcd_int32_asm);\n# if defined(__x86_64__)\n def(\"gcd_int64_asm\", gcd_int64_asm, (arg(\"a\"), arg(\"b\")));\n def(\"time_gcd_int64_asm\", time_gcd_int64_asm);\n# endif\n#endif\n\n def(\"floating_point_epsilon_float_get\",\n &floating_point_epsilon::get);\n def(\"floating_point_epsilon_double_get\",\n &floating_point_epsilon::get);\n\n def(\"erf\", (double(*)(double const&)) erf);\n def(\"erf\",\n (scitbx::af::shared(*)(\n scitbx::af::const_ref const&)) erf);\n def(\"erfc\", (double(*)(double const&)) erfc);\n def(\"erfcx\", (double(*)(double const&)) erfcx);\n\n def(\"parabolic_cylinder_d\", (double(*)(double, double))\n parabolic_cylinder_d::dv);\n\n // G-function\n def(\"GfuncOfRSsqr_approx\", (double(*)(double))\n g_function::GfuncOfRSsqr_approx);\n\n def(\"bessel_i1_over_i0\", (double(*)(double const&)) bessel::i1_over_i0);\n def(\"bessel_i1_over_i0\",\n (scitbx::af::shared(*)(scitbx::af::const_ref const&))\n bessel::i1_over_i0);\n def(\"bessel_inverse_i1_over_i0\",\n (double(*)(double const&)) bessel::inverse_i1_over_i0);\n def(\"inverse_bessel_i1_over_i0\", (scitbx::af::shared(*)(\n scitbx::af::const_ref const&)) bessel::inverse_i1_over_i0);\n def(\"bessel_i0\", (double(*)(double const&)) bessel::i0);\n def(\"bessel_i1\", (double(*)(double const&)) bessel::i1);\n def(\"bessel_ln_of_i0\", (double(*)(double const&)) bessel::ln_of_i0);\n def(\"ei1\", (double(*)(double const&)) bessel::ei1);\n def(\"ei0\", (double(*)(double const&)) bessel::ei0);\n\n typedef return_value_policy rbv;\n namespace smg=scitbx::math::gaussian_fit_1d_analytical;\n class_ >(\"gaussian_fit_1d_analytical\")\n .def(init<\n af::const_ref const&,\n af::const_ref const&,\n af::const_ref const& >(\n (arg(\"x\"),\n arg(\"y\"),\n arg(\"z\"))))\n .def(init<\n af::const_ref const&,\n af::const_ref const& >(\n (arg(\"x\"),\n arg(\"y\"))))\n .add_property(\"a\", make_getter(&smg::compute<>::a, rbv()))\n .add_property(\"b\", make_getter(&smg::compute<>::b, rbv()))\n ;\n\n //typedef return_value_policy rbv;\n namespace cueq=scitbx::math::cubic_equation;\n class_ >(\"cubic_equation_real\")\n .def(init<\n double const&,\n double const&,\n double const&,\n double const& >(\n (arg(\"a\"),\n arg(\"b\"),\n arg(\"c\"),\n arg(\"d\"))))\n .def(\"residual\", &cueq::real<>::residual)\n .add_property(\"x\", make_getter(&cueq::real<>::x, rbv()))\n .add_property(\"A\", make_getter(&cueq::real<>::A, rbv()))\n .add_property(\"B\", make_getter(&cueq::real<>::B, rbv()))\n .add_property(\"D\", make_getter(&cueq::real<>::D, rbv()))\n ;\n\n#if defined(SCITBX_MATH_BESSEL_HAS_SPHERICAL)\n def(\"spherical_bessel\",\n (double(*)(int const&, double const&))\n bessel::spherical_bessel);\n def(\"spherical_bessel_array\",\n (scitbx::af::shared< double> (*)(\n int const&, scitbx::af::shared const&))\n bessel::spherical_bessel_array);\n def(\"bessel_J\",\n (double(*)(int const&, double const&))\n bessel::bessel_J);\n def(\"bessel_J_array\",\n (scitbx::af::shared< double> (*)(\n int const&, scitbx::af::shared const&))\n bessel::bessel_J_array);\n def (\"bessel_J_zeroes\",\n (scitbx::af::shared< double> (*)(\n double const&, int const&))\n bessel::bessel_J_zeroes);\n def (\"sph_bessel_j_zeroes\",\n (scitbx::af::shared< double> (*)(\n double const&, int const&))\n bessel::sph_bessel_j_zeroes);\n\n\n#endif\n\n def(\"gamma_complete\", (double(*)(double const&, bool))\n gamma::complete, (\n arg(\"x\"),\n arg(\"minimax\")=true));\n def(\"gamma_incomplete\", (double(*)(double const&,\n double const&,\n unsigned))\n gamma::incomplete, (arg(\"a\"),\n arg(\"x\"),\n arg(\"max_iterations\")=500));\n def(\"gamma_incomplete_complement\",(double(*)(double const&,\n double const&,\n unsigned))\n gamma::incomplete_complement, (\n arg(\"a\"),\n arg(\"x\"),\n arg(\"max_iterations\")=500));\n def(\"exponential_integral_e1z\", (double(*)(double const&))\n gamma::exponential_integral_e1z );\n\n def(\"lambertw\", (double(*)(double const&, unsigned))\n lambertw, (\n arg(\"x\"),\n arg(\"max_iterations\")=100));\n\n wrap_basic_statistics();\n wrap_gaussian();\n wrap_golay();\n wrap_minimum_covering_sphere();\n wrap_principal_axes_of_inertia();\n wrap_row_echelon();\n wrap_tensor_rank_2();\n wrap_icosahedron();\n wrap_chebyshev_base();\n wrap_chebyshev_polynome();\n wrap_chebyshev_fitter();\n wrap_chebyshev_lsq();\n wrap_slatec();\n wrap_line_search();\n wrap_r3_rotation();\n wrap_resample();\n wrap_quadrature();\n wrap_unimodular_generator();\n wrap_halton();\n wrap_least_squares_plane();\n wrap_continued_fraction();\n wrap_numeric_limits();\n wrap_distributions();\n wrap_exp_functions();\n wrap_zernike();\n wrap_zernike_mom();\n wrap_2d_zernike_mom();\n wrap_weighted_covariance();\n wrap_dmatrix();\n wrap_correlation();\n wrap_interpolation();\n wrap_tetrahedron();\n wrap_angle_derivative();\n\n def(\"superpose_kearsley_rotation\", superpose_kearsley_rotation, (\n arg(\"reference_sites\"), arg(\"other_sites\")));\n\n def(\"dihedral_angle\",\n dihedral_angle, 4> >, (\n arg(\"sites\"), arg(\"deg\")=false));\n def(\"dihedral_angle\",\n dihedral_angle > >, (\n arg(\"sites\"), arg(\"deg\")=false));\n\n def( \"euler_angles_xyz_matrix\", euler_angles_xyz_matrix, (\n arg(\"ax\"), arg(\"ay\"), arg(\"az\")));\n def( \"euler_angles_xyz_angles\", euler_angles_xyz_angles, (\n arg(\"m\"), arg(\"eps\")=1e-12));\n\n def( \"euler_angles_yzx_matrix\", euler_angles_yzx_matrix, (\n arg(\"ay\"), arg(\"az\"), arg(\"ax\")));\n def( \"euler_angles_yzx_angles\", euler_angles_yzx_angles, (\n arg(\"m\"), arg(\"eps\")=1e-12));\n\n def( \"euler_angles_zyz_matrix\", euler_angles_zyz_matrix, (\n arg(\"az1\"), arg(\"ay\"), arg(\"az3\")));\n def( \"euler_angles_zyz_angles\", euler_angles_zyz_angles, (\n arg(\"m\"), arg(\"eps\")=1e-12));\n\n def(\"approx_sqrt\", math::approx_sqrt);\n\n def(\"cos_table\",\n (double(*)(\n af::const_ref const&,\n double,\n double const& ,\n int const& ,\n bool))\n math::cos_table, (\n arg(\"table\"), arg(\"arg\"), arg(\"step\"), arg(\"n\"),\n arg(\"interpolate\")));\n\n def(\"sin_table\",\n (double(*)(\n af::const_ref const&,\n double,\n double const& ,\n int const& ,\n bool))\n math::sin_table, (\n arg(\"table\"), arg(\"arg\"), arg(\"step\"), arg(\"n\"),\n arg(\"interpolate\")));\n\n def(\"signed_phase_error\",\n (double(*)(\n double const&, double const&, bool))\n math::signed_phase_error, (\n arg(\"phi1\"), arg(\"phi2\"), arg(\"deg\")=false));\n def(\"signed_phase_error\",\n (af::shared(*)(\n af::const_ref const&, af::const_ref const&, bool))\n math::signed_phase_error, (\n arg(\"phi1\"), arg(\"phi2\"), arg(\"deg\")=false));\n def(\"phase_error\",\n (double(*)(\n double const&, double const&, bool))\n math::phase_error, (\n arg(\"phi1\"), arg(\"phi2\"), arg(\"deg\")=false));\n def(\"phase_error\",\n (af::shared(*)(\n af::const_ref const&, af::const_ref const&, bool))\n math::phase_error, (\n arg(\"phi1\"), arg(\"phi2\"), arg(\"deg\")=false));\n def(\"nearest_phase\",\n (double(*)(\n double const&, double const&, bool))\n math::nearest_phase, (\n arg(\"reference\"), arg(\"other\"), arg(\"deg\")=false));\n def(\"nearest_phase\",\n (af::shared(*)(\n af::const_ref const&, af::const_ref const&, bool))\n math::nearest_phase, (\n arg(\"reference\"), arg(\"other\"), arg(\"deg\")=false));\n def(\"divmod\", math::divmod);\n approx_equal_relatively_wrapper::wrap();\n approx_equal_relatively_wrapper >::wrap();\n {\n af::tiny, 3> (*f1)(vec3 const &, vec3 const &,\n bool) = &orthonormal_basis;\n af::tiny, 3> (*f2)(vec3 const &, int,\n vec3 const &, int,\n bool) = &orthonormal_basis;\n def(\"orthonormal_basis\", f1, (arg(\"v0\"), arg(\"v1\"),\n arg(\"right_handed\")=true));\n def(\"orthonormal_basis\", f2, (arg(\"v0\"), arg(\"axis_index_1\"),\n arg(\"v1\"), arg(\"axis_index_2\"),\n arg(\"right_handed\")=true));\n }\n def(\"distance_difference_matrix\", distance_difference_matrix, (\n arg(\"sites1\"), arg(\"sites2\")));\n }\n\n}}}} // namespace scitbx::math::boost_python::\n\nBOOST_PYTHON_MODULE(scitbx_math_ext)\n{\n scitbx::math::boost_python::init_module();\n}\n", "meta": {"hexsha": "be2ee7bb1ef119df7682b6b25e106d6c4cccff57", "size": 16667, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "scitbx/math/boost_python/math_ext.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/math_ext.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/math_ext.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": 29.4469964664, "max_line_length": 81, "alphanum_fraction": 0.5971080578, "num_tokens": 4642, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8152325073083131, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.4984184590116949}} {"text": "#include \"PCE.h\"\n#include \"GeomCommonFunctions.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace PartDesignGui;\n\nLocalCS::LocalCS()\n{\n\torigin = Vector2d(0.0,0.0);\n\taxis_x = Vector2d(1.0,0.0);\n\taxis_y = Math::Functs::RotationAxis2d(axis_x, -Math::Math_PI / 2.0, Vector2d(0.0, 0.0));\n\tMath::Functs::SetVectorLength(axis_x, 1.0);\n\tMath::Functs::SetVectorLength(axis_y, 1.0);\n\tangle = Math::Functs::GetAngleBetween(axis_x, Vector2d(1.0, 0.0));\n\tif (axis_x[1] < 0.0) angle = 2 * M_PI - angle;\n\torigin_max_y = 0.0;\n\torigin_min_y = 0.0;\n\torigin_min_x = 0.0;\n\torigin_max_x = 0.0;\n\toffset_max_y = 0.0;\n\toffset_min_y = 0.0;\n\toffset_min_x = 0.0;\n\toffset_max_x = 0.0;\n}\nLocalCS::LocalCS(const Vector2d& o, const Vector2d& x)\n{\n\torigin = o;\n\taxis_x = x;\n\taxis_y = Math::Functs::RotationAxis2d(axis_x, -Math::Math_PI/2.0, Vector2d(0.0, 0.0));\n\tMath::Functs::SetVectorLength(axis_x, 1.0);\n\tMath::Functs::SetVectorLength(axis_y, 1.0);\n\tangle = Math::Functs::GetAngleBetween(axis_x, Vector2d(1.0, 0.0));\n\tif (axis_x[1] < 0.0) angle = 2 * M_PI - angle;\n\torigin_max_y = 0.0;\n\torigin_min_y = 0.0;\n\torigin_min_x = 0.0;\n\torigin_max_x = 0.0;\n\toffset_max_y = 0.0;\n\toffset_min_y = 0.0;\n\toffset_min_x = 0.0;\n\toffset_max_x = 0.0;\n}\n\nvoid LocalCS::SetCS(const Vector2d& o, const Vector2d& x)\n{\n\torigin = o;\n\taxis_x = x;\n\taxis_y = Math::Functs::RotationAxis2d(axis_x, -Math::Math_PI / 2.0, Vector2d(0.0, 0.0));\n\tMath::Functs::SetVectorLength(axis_x, 1.0);\n\tMath::Functs::SetVectorLength(axis_y, 1.0);\n\tangle = Math::Functs::GetAngleBetween(axis_x, Vector2d(1.0, 0.0));\n\tif (axis_x[1] < 0.0) angle = 2 * M_PI - angle;\n\torigin_max_y = 0.0;\n\torigin_min_y = 0.0;\n\torigin_min_x = 0.0;\n\torigin_max_x = 0.0;\n\toffset_max_y = 0.0;\n\toffset_min_y = 0.0;\n\toffset_min_x = 0.0;\n\toffset_max_x = 0.0;\n}\n\nVector2d LocalCS::GetLocal(const Vector2d& v) const\n{\n\tVector2d result = v - origin;\n\tresult = Math::Functs::RotationAxis2d(result, angle, Vector2d(0.0, 0.0));\n\treturn result;\n}\n\nVector2d1 LocalCS::GetLocal(const Vector2d1& points) const\n{\n\tVector2d1 results;\n\tfor (auto p : points)\n\t\tresults.emplace_back(GetLocal(p));\n\treturn results;\n}\n\n//need to check\nVector2d LocalCS::GetGlobalPos(const Vector2d& v) const\n{\n\tVector2d result = Math::Functs::RotationAxis2d(v, -angle, Vector2d(0.0, 0.0));\n\tresult = result + origin;\n\treturn result;\n}\n\nVector2d LocalCS::GetGlobalVec(const Vector2d& v) const\n{\n\tVector2d result = Math::Functs::RotationAxis2d(v, -angle, Vector2d(0.0, 0.0));\n\treturn result;\n}\n\nbool LocalCS::GetSegOrigin(const HMODULE& hModule, const double part_match_error, const Vector2d& s, const Vector2d& e, double& min_x, double& max_x) const\n{\n\tauto cgal_2d_inter_line_line = (CGAL_2D_Intersection_Line_Line)GetProcAddress(hModule, \"CGAL_2D_Intersection_Line_Line\");\n\tVector2d low_v = e;\n\tVector2d upper_v = s;\n\tif (s[1] <= e[1])\n\t{\n\t\tlow_v = s;\n\t\tupper_v = e;\n\t}\n\n\t//outside\n\tif (low_v[1] > origin_max_y || upper_v[1] < origin_min_y ||\n\t\tMath::Functs::IsAlmostZero_Double(low_v[1] - origin_max_y, part_match_error) || Math::Functs::IsAlmostZero_Double(upper_v[1] - origin_min_y, part_match_error))\n\t\treturn false;\n\n\t//all in\n\tif ((low_v[1] > origin_min_y||Math::Functs::IsAlmostZero_Double(low_v[1]- origin_min_y, part_match_error)) &&\n\t\t(upper_v[1] < origin_max_y||Math::Functs::IsAlmostZero_Double(upper_v[1]- origin_max_y, part_match_error)))\n\t{\n\t\tmin_x = low_v[0];\n\t\tmax_x = upper_v[0];\n\t\tif (low_v[0] > upper_v[0])\n\t\t{\n\t\t\tmin_x = upper_v[0];\n\t\t\tmax_x = low_v[0];\n\t\t}\n\t\treturn true;\n\t}\n\n\t//cutting lower\n\tif (low_v[1]< origin_min_y && upper_v[1]>origin_min_y && (upper_v[1] < origin_max_y||\n\t\tMath::Functs::IsAlmostZero_Double(upper_v[1]- origin_max_y, part_match_error)))\n\t{\n\t\tVector2d inter;\n\t\tif (cgal_2d_inter_line_line(low_v, upper_v, Vector2d(0.0, origin_min_y), Vector2d(1.0, origin_min_y), inter))\n\t\t{\n\t\t\tmin_x = inter[0];\n\t\t\tmax_x = upper_v[0];\n\t\t\tif (inter[0] > upper_v[0])\n\t\t\t{\n\t\t\t\tmin_x = upper_v[0];\n\t\t\t\tmax_x = inter[0];\n\t\t\t}\n\t\t\treturn true;\n\t\t}\n\t}\n\n\t//cutting upper\n\tif (upper_v[1] > origin_max_y && (low_v[1] > origin_min_y||Math::Functs::IsAlmostZero_Double(low_v[1]- origin_min_y, part_match_error)) && low_v[1] < origin_max_y)\n\t{\n\t\tVector2d inter;\n\t\tif (cgal_2d_inter_line_line(low_v, upper_v, Vector2d(0.0, origin_max_y), Vector2d(1.0, origin_max_y), inter))\n\t\t{\n\t\t\tmin_x = low_v[0];\n\t\t\tmax_x = inter[0];\n\t\t\tif (low_v[0] > inter[0])\n\t\t\t{\n\t\t\t\tmin_x = inter[0];\n\t\t\t\tmax_x = low_v[0];\n\t\t\t}\n\t\t\treturn true;\n\t\t}\n\t}\n\n\n\tif (upper_v[1] > origin_max_y && low_v[1] < origin_min_y)\n\t{\n\t\tVector2d inter_0;\n\t\tbool b0 = cgal_2d_inter_line_line(low_v, upper_v, Vector2d(0.0, origin_min_y), Vector2d(1.0, origin_min_y), inter_0);\n\t\tVector2d inter_1;\n\t\tbool b1 = cgal_2d_inter_line_line(low_v, upper_v, Vector2d(0.0, origin_max_y), Vector2d(1.0, origin_max_y), inter_1);\n\n\t\tif (b0 && b1)\n\t\t{\n\t\t\tmin_x = inter_0[0];\n\t\t\tmax_x = inter_1[0];\n\t\t\tif (inter_0[0] > inter_1[0])\n\t\t\t{\n\t\t\t\tmin_x = inter_1[0];\n\t\t\t\tmax_x = inter_0[0];\n\t\t\t}\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\nbool LocalCS::GetSegOffset(const HMODULE& hModule, const double part_match_error, const Vector2d& s, const Vector2d& e, double& min_x, double& max_x) const\n{\n\tauto cgal_2d_inter_line_line = (CGAL_2D_Intersection_Line_Line)GetProcAddress(hModule, \"CGAL_2D_Intersection_Line_Line\");\n\n\tVector2d low_v = e;\n\tVector2d upper_v = s;\n\tif (s[1] <= e[1])\n\t{\n\t\tlow_v = s;\n\t\tupper_v = e;\n\t}\n\n\t//outside\n\tif (low_v[1] > offset_max_y || upper_v[1] < offset_min_y ||\n\t\tMath::Functs::IsAlmostZero_Double(low_v[1] - offset_max_y, part_match_error) ||\n\t\tMath::Functs::IsAlmostZero_Double(upper_v[1] - offset_min_y, part_match_error))\n\t\treturn false;\n\n\t//all in\n\tif (low_v[1] >= offset_min_y && upper_v[1] <= offset_max_y)\n\t{\n\t\tmin_x = low_v[0];\n\t\tmax_x = upper_v[0];\n\t\tif (low_v[0] > upper_v[0])\n\t\t{\n\t\t\tmin_x = upper_v[0];\n\t\t\tmax_x = low_v[0];\n\t\t}\n\t\treturn true;\n\t}\n\n\t//cutting lower\n\tif (low_v[1]< offset_min_y && upper_v[1]>offset_min_y && upper_v[1] <= offset_max_y)\n\t{\n\t\tVector2d inter;\n\t\tif (cgal_2d_inter_line_line(low_v, upper_v, Vector2d(0.0, offset_min_y), Vector2d(1.0, offset_min_y), inter))\n\t\t{\n\t\t\tmin_x = inter[0];\n\t\t\tmax_x = upper_v[0];\n\t\t\tif (inter[0] > upper_v[0])\n\t\t\t{\n\t\t\t\tmin_x = upper_v[0];\n\t\t\t\tmax_x = inter[0];\n\t\t\t}\n\t\t\treturn true;\n\t\t}\n\t}\n\n\t//cutting upper\n\tif (upper_v[1] > offset_max_y && low_v[1] >= offset_min_y && low_v[1] < offset_max_y)\n\t{\n\t\tVector2d inter;\n\t\tif (cgal_2d_inter_line_line(low_v, upper_v, Vector2d(0.0, offset_max_y), Vector2d(1.0, offset_max_y), inter))\n\t\t{\n\t\t\tmin_x = low_v[0];\n\t\t\tmax_x = inter[0];\n\t\t\tif (low_v[0] > inter[0])\n\t\t\t{\n\t\t\t\tmin_x = inter[0];\n\t\t\t\tmax_x = low_v[0];\n\t\t\t}\n\t\t\treturn true;\n\t\t}\n\t}\n\n\n\tif (upper_v[1] > offset_max_y && low_v[1] < offset_min_y)\n\t{\n\t\tVector2d inter_0;\n\t\tbool b0 = cgal_2d_inter_line_line(low_v, upper_v, Vector2d(0.0, offset_min_y), Vector2d(1.0, offset_min_y), inter_0);\n\t\tVector2d inter_1;\n\t\tbool b1 = cgal_2d_inter_line_line(low_v, upper_v, Vector2d(0.0, offset_max_y), Vector2d(1.0, offset_max_y), inter_1);\n\n\t\tif (b0 && b1)\n\t\t{\n\t\t\tmin_x = inter_0[0];\n\t\t\tmax_x = inter_1[0];\n\t\t\tif (inter_0[0] > inter_1[0])\n\t\t\t{\n\t\t\t\tmin_x = inter_1[0];\n\t\t\t\tmax_x = inter_0[0];\n\t\t\t}\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\nVector2d1 LocalCS::SortX(const Vector2d1& segs) const\n{\n\tVector2d1 sort_segs;\n\tif (segs.size() == 0) return sort_segs;\n\tdouble minimal_x = segs[0][0];\n\tdouble maximal_x = segs[0][1];\n\n\tfor (int iter = 0; iter < segs.size(); iter++)\n\t{\n\t\tauto& seg = segs[iter];\n\t\tif (seg[0] >= minimal_x && seg[0] <= maximal_x)\n\t\t{\n\t\t\tif (seg[1] > maximal_x)\n\t\t\t\tmaximal_x = seg[1];\n\t\t}\n\t\telse\n\t\t{\n\t\t\tsort_segs.emplace_back(minimal_x, maximal_x);\n\t\t\tminimal_x = segs[iter][0];\n\t\t\tmaximal_x = segs[iter][1];\n\t\t}\n\n\t\tif (iter == segs.size() - 1)\n\t\t{\n\t\t\tsort_segs.emplace_back(minimal_x, maximal_x);\n\t\t\tbreak;\n\t\t}\n\t}\n\treturn sort_segs;\n}\n\nVector2d1 LocalCS::EmptyX(const Vector2d1& sort_segs) const\n{\n\tVector2d1 empty_segs;\n\tfor (int i = 1; i < sort_segs.size(); i++)\n\t\tempty_segs.emplace_back(sort_segs[i - 1][1], sort_segs[i][0]);\n\treturn empty_segs;\n}", "meta": {"hexsha": "18e738ea586b8373f26ac80a06f24bb78ac7bf82", "size": 8079, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Gui/PCE_CS.cpp", "max_stars_repo_name": "haisenzhao/CarpentryCompiler", "max_stars_repo_head_hexsha": "c9714310b7ce7523a25becd397265bfaa3ab7ea3", "max_stars_repo_licenses": ["FSFAP"], "max_stars_count": 21.0, "max_stars_repo_stars_event_min_datetime": "2019-12-06T09:57:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-22T12:58:09.000Z", "max_issues_repo_path": "Gui/PCE_CS.cpp", "max_issues_repo_name": "haisenzhao/CarpentryCompiler", "max_issues_repo_head_hexsha": "c9714310b7ce7523a25becd397265bfaa3ab7ea3", "max_issues_repo_licenses": ["FSFAP"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Gui/PCE_CS.cpp", "max_forks_repo_name": "haisenzhao/CarpentryCompiler", "max_forks_repo_head_hexsha": "c9714310b7ce7523a25becd397265bfaa3ab7ea3", "max_forks_repo_licenses": ["FSFAP"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2020-11-18T00:09:30.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-13T04:40:47.000Z", "avg_line_length": 26.0612903226, "max_line_length": 164, "alphanum_fraction": 0.6712464414, "num_tokens": 3063, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8152324893519999, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.49841844803352875}} {"text": "/*\n For more information, please see: http://software.sci.utah.edu\n\n The MIT License\n\n Copyright (c) 2015 Scientific Computing and Imaging Institute,\n University of Utah.\n\n \n Permission is hereby granted, free of charge, to any person obtaining a\n copy of this software and associated documentation files (the \"Software\"),\n to deal in the Software without restriction, including without limitation\n the rights to use, copy, modify, merge, publish, distribute, sublicense,\n and/or sell copies of the Software, and to permit persons to whom the\n Software is furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included\n in all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n DEALINGS IN THE SOFTWARE.\n*/\n/// @todo Documentation Core/Datatypes/Legacy/Matrix/DenseMatrix.cc\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \n\n#include \n\n#include \n\nnamespace SCIRun {\n\n// NOTE: returns 1 if successful, or 0 if unsuccessful (i.e. ignore the solution vector)\nint\nLinearAlgebra::solve(const DenseMatrix& matrix, ColumnMatrix& sol)\n{\n ColumnMatrix b(sol);\n return solve(matrix, b, sol);\n}\n\n\n// NOTE: returns 1 if successful, or 0 if unsuccessful (i.e. ignore the solution vector)\nint\nLinearAlgebra::solve(const DenseMatrix& matrix, const ColumnMatrix& rhs, ColumnMatrix& lhs)\n{\n ASSERT(matrix.nrows() == matrix.ncols());\n ASSERT(rhs.nrows() == matrix.ncols());\n lhs=rhs;\n\n double **A;\n double **cpy = 0;\n double *lhsp = lhs.get_data_pointer();\n\t\n cpy = new double*[matrix.nrows()]; \n\n for (index_type j=0; j < matrix.nrows(); j++)\n cpy[j] = matrix.get_raw_2D_pointer()[j];\n\n A = cpy;\n\n // Gauss-Jordan with partial pivoting\n index_type i;\n for (i=0; i < matrix.nrows(); i++)\n {\n double max=Abs(A[i][i]);\n index_type row=i;\n index_type j;\n for (j=i+1; j < matrix.nrows(); j++)\n {\n if(Abs(A[j][i]) > max)\n {\n max=Abs(A[j][i]);\n row=j;\n }\n }\n // ASSERT(Abs(max) > 1.e-12);\n if (Abs(max) < 1.e-12)\n {\n lhs=rhs;\n delete cpy;\n return 0;\n }\n if(row != i)\n {\n // Switch rows (actually their pointers)\n std::swap(A[i], A[row]);\n std::swap(lhsp[i], lhsp[row]);\n }\n double denom=1./A[i][i];\n double* r1=A[i];\n double s1=lhsp[i];\n for (j=i+1; j 1.e-12);\n if (Abs(A[i][i]) < 1.e-12)\n {\n lhs=rhs;\n delete cpy;\n return 0;\n }\n double denom=1./A[i][i];\n double* r1=A[i];\n double s1=lhsp[i];\n for (index_type j=0;j 1.e-12);\n if (Abs(A[i][i]) < 1.e-12)\n {\n lhs=rhs;\n delete cpy;\n return 0;\n }\n double factor=1./A[i][i];\n for (index_type j=0; j sigma(new double[SIGMA_LEN]);\n\n try\n {\n lapacksvd(matrix.get_raw_2D_pointer(), matrix.nrows(), matrix.ncols(), sigma.get(), U.get_raw_2D_pointer(), VT.get_raw_2D_pointer());\n }\n catch (const SCIRun::LapackError& exception)\n {\n std::ostringstream oss;\n oss << \"Caught LapackError exception: \" << exception.message();\n // in the absence of a logging service\n std::cerr << oss.str() << std::endl;\n throw;\n }\n\n size_type nnz = 0;\n for (size_type i = 0; i < SIGMA_LEN; ++i)\n {\n if ( fabs(sigma[i]) >= std::numeric_limits::epsilon() )\n {\n ++nnz;\n }\n }\n\n SparseRowMatrix::Data sparseData(matrix.nrows() + 1, nnz);\n const SparseRowMatrix::Rows& rows = sparseData.rows();\n const SparseRowMatrix::Columns& columns = sparseData.columns();\n const SparseRowMatrix::Storage& a = sparseData.data();\n if (!sparseData.allocated())\n {\n std::cerr << \"Could not allocate memory for sparse matrix buffers \"\n << __FILE__ << \": \" << __LINE__ << std::endl;\n\n return;\n }\n\n // singular values on diagonal\n index_type count = 0;\n index_type i = 0;\n const index_type NROWS = matrix.nrows();\n for (index_type r = 0; r < NROWS; r++)\n {\n rows[r] = count;\n if ( r < matrix.ncols() && i < SIGMA_LEN && fabs(sigma[i]) >= std::numeric_limits::epsilon() )\n {\n columns[count] = r;\n a[count] = sigma[i];\n ++count;\n ++i;\n }\n }\n rows[matrix.nrows()] = count;\n \n S = new SparseRowMatrix(matrix.nrows(), matrix.ncols(), sparseData, nnz);\n}\n\nvoid\nLinearAlgebra::svd(const DenseMatrix& matrix, DenseMatrix& U, DenseMatrix& S, DenseMatrix& VT)\n{\n ASSERTEQ(U.ncols(), U.nrows());\n ASSERTEQ(VT.ncols(), VT.nrows());\n ASSERTEQ(U.nrows(), matrix.nrows());\n ASSERTEQ(VT.ncols(), matrix.ncols());\n ASSERTEQ(S.nrows(), matrix.nrows());\n ASSERTEQ(S.ncols(), matrix.ncols());\n\n /*\n * LAPACK function dgesvd argument S is a DOUBLE PRECISION array\n * with dimension (min(M,N)).\n */\n const size_type SIGMA_LEN = std::min(matrix.nrows(), matrix.ncols());\n boost::shared_array sigma(new double[SIGMA_LEN]);\n\n try\n {\n lapacksvd(matrix.get_raw_2D_pointer(), matrix.nrows(), matrix.ncols(), sigma.get(), U.get_raw_2D_pointer(), VT.get_raw_2D_pointer());\n }\n catch (const SCIRun::LapackError& exception)\n {\n std::ostringstream oss;\n oss << \"Caught LapackError exception: \" << exception.message();\n // in the absence of a logging service\n std::cerr << oss.str() << std::endl;\n throw;\n }\n\n // Put singular values on diagonal.\n for (size_type i = 0; i < SIGMA_LEN; ++i)\n S.put(i, i, sigma[i]);\n}\n\nvoid\nLinearAlgebra::svd(const DenseMatrix& matrix, DenseMatrix& U, ColumnMatrix& S, DenseMatrix& VT)\n{\n // Check whether matrices are square\n if (U.ncols() != U.nrows())\n {\n SCI_THROW(DimensionMismatch(U.ncols(), U.nrows(), __FILE__, __LINE__));\n }\n \n if (VT.ncols() != VT.nrows())\n {\n SCI_THROW(DimensionMismatch(VT.ncols(), VT.nrows(), __FILE__, __LINE__));\n }\n \n if (U.nrows())\n {\n if (U.nrows() != matrix.nrows())\n {\n SCI_THROW(DimensionMismatch(U.nrows(), matrix.nrows(), __FILE__, __LINE__));\n } \n }\n if (VT.ncols())\n {\n if (VT.ncols() != matrix.ncols())\n {\n SCI_THROW(DimensionMismatch(VT.ncols(), matrix.ncols(), __FILE__, __LINE__));\n }\n }\n \n if (matrix.nrows() < matrix.ncols())\n {\n if (S.nrows() != matrix.nrows())\n {\n SCI_THROW(DimensionMismatch(S.nrows(), matrix.nrows(), __FILE__, __LINE__));\n }\n }\n else\n {\n if (S.nrows() != matrix.ncols())\n {\n SCI_THROW(DimensionMismatch(S.nrows(), matrix.ncols(), __FILE__, __LINE__));\n }\n }\n\n try\n {\n if (U.nrows() == 0 && VT.nrows() == 0)\n lapacksvd(matrix.get_raw_2D_pointer(), matrix.nrows(), matrix.ncols(), S.get_data_pointer(), 0, 0);\n else if (U.nrows() != 0 && VT.nrows() == 0)\n lapacksvd(matrix.get_raw_2D_pointer(), matrix.nrows(), matrix.ncols(), S.get_data_pointer(), U.get_raw_2D_pointer(), 0);\n else if (U.nrows() == 0 && VT.nrows() != 0)\n lapacksvd(matrix.get_raw_2D_pointer(), matrix.nrows(), matrix.ncols(), S.get_data_pointer(), 0, VT.get_raw_2D_pointer());\n else \n lapacksvd(matrix.get_raw_2D_pointer(), matrix.nrows(), matrix.ncols(), S.get_data_pointer(), U.get_raw_2D_pointer(), VT.get_raw_2D_pointer());\n }\n catch (const SCIRun::LapackError& exception)\n {\n std::ostringstream oss;\n oss << \"Caught LapackError exception: \" << exception.message();\n // in the absence of a logging service\n std::cerr << oss.str() << std::endl;\n throw;\n }\n}\n\nvoid\nLinearAlgebra::eigenvalues(const DenseMatrix& matrix, ColumnMatrix& R, ColumnMatrix& I)\n{\n ASSERTEQ(matrix.ncols(), matrix.nrows());\n ASSERTEQ(R.nrows(), I.nrows());\n ASSERTEQ(matrix.ncols(), R.nrows());\n\n boost::shared_array Er(new double[matrix.nrows()]);\n boost::shared_array Ei(new double[matrix.nrows()]);\n\n try\n {\n lapackeigen(matrix.get_raw_2D_pointer(), matrix.nrows(), Er.get(), Ei.get());\n }\n catch (const SCIRun::LapackError& exception)\n {\n std::ostringstream oss;\n oss << \"Caught LapackError exception: \" << exception.message();\n // in the absence of a logging service\n std::cerr << oss.str() << std::endl;\n throw;\n }\n\n for (index_type i = 0; i < matrix.nrows(); i++)\n {\n R[i] = Er[i];\n I[i] = Ei[i];\n }\n}\n\nvoid\nLinearAlgebra::eigenvectors(const DenseMatrix& matrix, ColumnMatrix& R, ColumnMatrix& I, DenseMatrix& Vecs)\n{\n ASSERTEQ(matrix.ncols(), matrix.nrows());\n ASSERTEQ(R.nrows(), I.nrows());\n ASSERTEQ(matrix.ncols(), R.nrows());\n\n boost::shared_array Er(new double[matrix.nrows()]);\n boost::shared_array Ei(new double[matrix.nrows()]);\n\n try\n {\n lapackeigen(matrix.get_raw_2D_pointer(), matrix.nrows(), Er.get(), Ei.get(), Vecs.get_raw_2D_pointer());\n }\n catch (const SCIRun::LapackError& exception)\n {\n std::ostringstream oss;\n oss << \"Caught LapackError exception: \" << exception.message();\n // in the absence of a logging service\n std::cerr << oss.str() << std::endl;\n throw;\n }\n\n\n for (index_type i = 0; i\n#include \n#include \n#include \n#include \n#include \n\n// Dependencies required for eigenvalue computation\n#include \n#include \n#include \n#include \n#include \n\nusing namespace Rodin;\nusing namespace Rodin::Variational;\nusing namespace Rodin::External;\n\nEigen::SparseMatrix mfemToEigenSparse(mfem::SparseMatrix m)\n{\n typedef Eigen::Triplet Triplet;\n\n int nonZero = m.NumNonZeroElems();\n std::vector tripletList;\n\n // Get the values (i,j, data)\n int* m_I = m.GetI();\n int* m_J = m.GetJ();\n double* m_data = m.GetData();\n\n for(int r = 0; r < m.NumRows(); ++r){\n for(int j=m_I[r]; j m_sparse(m.NumRows(), m.NumCols());\n m_sparse.setFromTriplets(tripletList.begin(), tripletList.end()); //SEGFAULT\n\n return m_sparse;\n}\n\n\nclass EigenSolver{\n\n public:\n // Constructors\n EigenSolver();\n\n // Destructor\n ~EigenSolver() = default;\n\n // Accessors\n GridFunction

& getEigenFunction(int index);\n\n double getEigenValue(int index);\n std::vector getEigenValues();\n\n // Options\n EigenSolver& setNumEV(unsigned int nev);\n EigenSolver& setShift(double shift);\n\n // Solves the problem\n void solve(mfem::SparseMatrix A, mfem::SparseMatrix B, FiniteElementSpace

& fes);\n\n private:\n std::vector m_eigenvalues;\n std::vector*> m_eigenfunctions;\n unsigned int m_nev;\n double m_shift;\n};\n\n\n\nint main(int argc, char** argv)\n{\n const char* meshFile = \"../resources/mfem/levelset-cantilever2d-example.mesh\";\n\n // Define interior and exterior for level set discretization\n int Interior = 1, Exterior = 2;\n\n // Define boundary attributes\n int Gamma0 = 1, GammaD = 2, GammaN = 3, Gamma = 4;\n\n // Load mesh\n Mesh Omega;\n Omega.load(meshFile);\n\n // Solver for hilbertian regularization\n auto solver = Solver::UMFPack();\n\n // Optimization parameters\n size_t maxIt = 100;\n double eps = 1e-6;\n double hmax = 0.05;\n int k = 1; // The eigenvalue to optimize\n auto alpha = ScalarFunction(4 * hmax * hmax); // Parameter for hilbertian regularization\n\n std::vector obj;\n\n /*\n // Scalar field finite element space over the whole domain\n FiniteElementSpace

Vh(Omega);\n\n // Trim the exterior part of the mesh to solve the elasticity system\n SubMesh trimmed = Omega.trim(Exterior, Gamma);\n\n // Build a finite element space over the trimmed mesh\n FiniteElementSpace

VhInt(trimmed);\n\n // Elasticity equation\n TrialFunction uInt(VhInt);\n TestFunction vInt(VhInt);\n\n // A\n Problem stiffness(uInt, vInt);\n stiffness = Integral(Grad(uInt), Grad(vInt));\n stiffness.update().assemble();\n\n // B\n Problem mass(uInt, vInt);\n mass = Integral(uInt, vInt);\n mass.update().assemble();\n\n auto& m1 = stiffness.getStiffnessMatrix();\n auto& m2 = mass.getStiffnessMatrix();\n\n\n // Solve eigenvalue problem\n EigenSolver ES;\n ES.setShift(1.0).setNumEV(k+4).solve(m1, m2, VhInt);\n\n // Get solution and transfer to original domain\n GridFunction u(Vh);\n ES.getEigenFunction(k).transfer(u);\n double mu = ES.getEigenValue(k);\n\n // Save solution\n u.save(\"u.gf\");\n Omega.save(\"Omega.mesh\");\n */\n\n // Optimization loop\n for (size_t i = 0; i < maxIt; i++)\n {\n // Scalar field finite element space over the whole domain\n FiniteElementSpace

Vh(Omega);\n\n // Trim the exterior part of the mesh to solve the elasticity system\n SubMesh trimmed = Omega.trim(Exterior, Gamma);\n\n // Build a finite element space over the trimmed mesh\n FiniteElementSpace

VhInt(trimmed);\n\n // Elasticity equation\n TrialFunction uInt(VhInt);\n TestFunction vInt(VhInt);\n\n // A\n Problem stiffness(uInt, vInt);\n stiffness = Integral(Grad(uInt), Grad(vInt));\n stiffness.update().assemble();\n\n // B\n Problem mass(uInt, vInt);\n mass = Integral(uInt, vInt);\n mass.update().assemble();\n\n auto& m1 = stiffness.getStiffnessMatrix();\n auto& m2 = mass.getStiffnessMatrix();\n\n\n // Solve eigenvalue problem\n EigenSolver ES;\n ES.setShift(1.0).setNumEV(k+4).solve(m1, m2, VhInt);\n\n // Get solution and transfer to original domain\n GridFunction u(Vh);\n ES.getEigenFunction(k).transfer(u);\n double mu = ES.getEigenValue(k);\n\n // Compute the boundary shape gradientv\n // Vector field finite element space over the whole domain\n FiniteElementSpace

Uh(Omega, 2);\n auto n = Normal(2);\n\n // GridFunction dJ(Uh);\n //dJ = Omega.getVolume(Interior)*(Dot(Grad(u), Grad(u)) + mu*Dot(u,u))*n + mu*n; // /Integral(Dot(u,u)) sur le sous-mesh\n //std::cout << dJ.getFiniteElementSpace().getVectorDimension() << std::endl;\n\n // Note from Carlos: 26/Avril/2022\n // Salut !\n // 1. I changed some things around, in particular I do not project the\n // expression for dJ on a GridFunction. Instead I wrote the thing directly\n // and hope that Rodin understands what I want hehe\n // 2. I fixed the bug in the transfer function, thank you for testing this\n // and narrowing down the problem! It helps a lot :)\n // 3. I tried to run your code and it seems that the objective goes down\n // but at one point the computation fails. I think due to parasitic\n // components.\n // 4. In the hilbertian procedure I removed the use of DirichletBC and used\n // the usual expression.\n //\n // See you soon!\n\n // Hilbert extension-regularization procedure\n // This is bullshit\n auto dJ = Dot(Grad(u).traceOf(Interior), Grad(u).traceOf(Interior)) * n;\n TrialFunction g(Uh);\n TestFunction v(Uh);\n Problem hilbert(g, v);\n hilbert = Integral(alpha * Jacobian(g), Jacobian(v))\n + Integral(g, v)\n + BoundaryIntegral(dJ, v).over(Gamma);\n solver.solve(hilbert);\n\n // Save data to inspect\n // Omega.save(\"Omegai.mesh\");\n // g.getGridFunction().save(\"g.gf\");\n\n // Update objective\n obj.push_back(\n mu * Omega.getVolume(Interior));\n std::cout << \"[\" << i << \"] Objective: \" << obj.back() << std::endl;\n\n // Convert data types to mmg types\n auto mmgMesh = Cast(Omega).to();\n auto mmgVel = Cast(g.getGridFunction()).to(mmgMesh);\n\n // Generate signed distance function\n auto mmgLs = MMG::Distancer2D().setInteriorDomain(Interior).distance(mmgMesh);\n\n // Advect the level set function\n double gInf = std::max(g.getGridFunction().max(), -g.getGridFunction().min());\n double dt = hmax / gInf;\n MMG::Advect2D(mmgLs, mmgVel).step(dt);\n\n // Recover the implicit domain\n auto mmgImplicit =\n MMG::ImplicitDomainMesher2D().split(Interior, {Interior, Exterior})\n .split(Exterior, {Interior, Exterior})\n .setRMC(1e-3)\n .setHMax(hmax)\n .setBoundaryReference(Gamma)\n .discretize(mmgLs);\n\n // Convert back to Rodin data type\n Omega = Cast(mmgImplicit).to>();\n\n // Save mesh\n Omega.save(\"Omega.mesh\");\n\n // Test for convergence\n if (obj.size() >= 2 && abs(obj[i] - obj[i - 1]) < eps)\n {\n std::cout << \"Convergence!\" << std::endl;\n break;\n }\n\n std::ofstream plt(\"obj.txt\", std::ios::trunc);\n for (size_t i = 0; i < obj.size(); i++)\n plt << i << \",\" << obj[i] << \"\\n\";\n }\n\n\n\n return 0;\n}\n\n\n// Constructor\nEigenSolver::EigenSolver(){\n m_nev = 0;\n m_shift = 0.0;\n}\n\n// Accessors\nGridFunction

& EigenSolver::getEigenFunction(int index){\n return *m_eigenfunctions[index];\n}\n\ndouble EigenSolver::getEigenValue(int index){\n return m_eigenvalues[index];\n}\n\nstd::vector EigenSolver::getEigenValues(){\n return m_eigenvalues;\n}\n\n// Options\nEigenSolver& EigenSolver::setNumEV(unsigned int nev){\n m_nev = nev;\n return *this;\n}\n\nEigenSolver& EigenSolver::setShift(double shift){\n m_shift = shift;\n\n return *this;\n}\n\nvoid EigenSolver::solve(mfem::SparseMatrix A,mfem::SparseMatrix B, FiniteElementSpace

& fes){\n\n // 1. CA and B to Eigen::SparseMatrix\n //WARNING: MAY BE USELESS SINCE SPECTRA HANDLE OTHER MATRICES TYPES\n //BUT MAY BE FASTER. IN FACT I DON'T HAVE A CLUE.\n Eigen::SparseMatrix A_sparse = mfemToEigenSparse(A);\n Eigen::SparseMatrix B_sparse = mfemToEigenSparse(B);\n\n // 2. Use Spectra with the shift-inverse method to compute eigenvalue\n // Define the shift-inverse and vector-multiplication operations\n using OpType = Spectra::SymShiftInvert;\n using BOpType = Spectra::SparseSymMatProd;\n OpType op(A_sparse, B_sparse);\n BOpType Bop(B_sparse);\n\n // Construct the generalized eigensolver object\n int ncv = 2*m_nev+1;\n Spectra::SymGEigsShiftSolver\n geigs(op, Bop, m_nev, ncv, m_shift);\n\n\n // Initialize and compute\n geigs.init();\n int nconv = geigs.compute(Spectra::SortRule::LargestMagn); // UTILISER LARGESTMAGN ET PAS SMALLESTMAGN CAR ON EST EN SHIFT-INVERSE MODE\n\n // Retrieve results\n Eigen::VectorXd evalues;\n Eigen::MatrixXd evecs;\n if (geigs.info() == Spectra::CompInfo::Successful)\n {\n evalues = geigs.eigenvalues();\n evecs = geigs.eigenvectors();\n }\n\n\n // Store in m_eigenvalues and m_eigenfunctions\n // (and reverse the order to order from lowest to higest)\n int dim = evecs.rows();\n\n for(int i = 0; i < m_nev; i++){\n m_eigenvalues.push_back(evalues[m_nev-i-1]);\n\n std::unique_ptr data(new double[dim]);\n for(int j=0; j(fes));\n m_eigenfunctions[i]->setData(std::move(data), dim);\n }\n}\n", "meta": {"hexsha": "c99a9b661a119ab6f814dafb3325a23841d01a2c", "size": 10108, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/ShapeOptimization/LevelSetEigenvalue2D.cpp", "max_stars_repo_name": "carlos-brito-pacheco/rodin", "max_stars_repo_head_hexsha": "f2c946b290ebb2487a21c617de01be91a0692c72", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-12-02T19:04:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-02T19:04:38.000Z", "max_issues_repo_path": "examples/ShapeOptimization/LevelSetEigenvalue2D.cpp", "max_issues_repo_name": "cbritopacheco/rodin", "max_issues_repo_head_hexsha": "f2c946b290ebb2487a21c617de01be91a0692c72", "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": "examples/ShapeOptimization/LevelSetEigenvalue2D.cpp", "max_forks_repo_name": "cbritopacheco/rodin", "max_forks_repo_head_hexsha": "f2c946b290ebb2487a21c617de01be91a0692c72", "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.6345609065, "max_line_length": 137, "alphanum_fraction": 0.6612584092, "num_tokens": 2843, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.815232489352, "lm_q2_score": 0.611381973294151, "lm_q1q2_score": 0.4984184480335287}} {"text": "#ifndef TVMTL_MANIFOLD_SPD_HPP\n#define TVMTL_MANIFOLD_SPD_HPP\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n//own includes\n#include \"enumerators.hpp\"\n#include \"matrix_utils.hpp\"\n\nnamespace tvmtl {\n\n// Specialization SPD\ntemplate \nstruct Manifold< SPD, N> {\n \n public:\n\tstatic const MANIFOLD_TYPE MyType;\n\tstatic const int manifold_dim ;\n\tstatic const int value_dim; // TODO: maybe rename to embedding_dim \n\n\tstatic const bool non_isometric_embedding;\n\t\n\t// Scalar type of manifold\n\ttypedef double scalar_type;\n\ttypedef double dist_type;\n\ttypedef std::complex complex_type;\n\ttypedef std::vector weight_list; \n\n\t// Value Typedef\n\ttypedef Eigen::Matrix< scalar_type, N, N>\t\t\t\tvalue_type;\n\ttypedef value_type&\t\t\t\t\t\t\tref_type;\n\ttypedef const value_type&\t\t\t\t\t\tcref_type;\n\ttypedef std::vector >\tvalue_list; \n\t\n\t// Tangent space typedefs\n\ttypedef Eigen::Matrix tm_base_type;\n\ttypedef tm_base_type&\t\t\t\t\t tm_base_ref_type;\n\n\t// Derivative Typedefs\n\ttypedef value_type\t\t\t deriv1_type;\n\ttypedef deriv1_type&\t\t\t deriv1_ref_type;\n\t\n\ttypedef Eigen::Matrix\t\t\t\tderiv2_type;\n\ttypedef deriv2_type&\t\t\t\t\t\t\tderiv2_ref_type;\n\ttypedef\tEigen::Matrix\trestricted_deriv2_type;\n\n\n\t// Manifold distance functions (for IRLS)\n\tinline static dist_type dist_squared(cref_type x, cref_type y);\n\tinline static void deriv1x_dist_squared(cref_type x, cref_type y, deriv1_ref_type result);\n\tinline static void deriv1y_dist_squared(cref_type x, cref_type y, deriv1_ref_type result);\n\n\tinline static void deriv2xx_dist_squared(cref_type x, cref_type y, deriv2_ref_type result);\n\tinline static void deriv2xy_dist_squared(cref_type x, cref_type y, deriv2_ref_type result);\n\tinline static void deriv2yy_dist_squared(cref_type x, cref_type y, deriv2_ref_type result);\n\n\n\t// Manifold exponentials und logarithms ( for Proximal point)\n\ttemplate \n\tinline static void exp(const Eigen::MatrixBase& x, const Eigen::MatrixBase& y, Eigen::MatrixBase& result);\n\tinline static void log(cref_type x, cref_type y, ref_type result);\n\n\tinline static void convex_combination(cref_type x, cref_type y, double t, ref_type result);\n\n\t// Implementations of the Karcher mean\n\t// Slow list version\n\tinline static void karcher_mean(ref_type x, const value_list& v, double tol=1e-10, int maxit=15);\n\tinline static void weighted_karcher_mean(ref_type x, const weight_list& w, const value_list& v, double tol=1e-10, int maxit=15);\n\t// Variadic templated version\n\ttemplate \n\tinline static void karcher_mean(V& x, const Args&... args);\n\ttemplate \n\tinline static void variadic_karcher_mean_gradient(V& x, const V& y);\n\ttemplate \n\tinline static void variadic_karcher_mean_gradient(V& x, const V& y1, const Args&... args);\n\t\n\t// Basis transformation for restriction to tangent space\n\tinline static void tangent_plane_base(cref_type x, tm_base_ref_type result);\n\n\t// Projection\n\tinline static void projector(ref_type x);\n\n\t// Interpolation pre- and postprocessing\n\tinline static void interpolation_preprocessing(ref_type x);\n\tinline static void interpolation_postprocessing(ref_type x);\n\n};\n\n\n/*-----IMPLEMENTATION SPD----------*/\n\n// Static constants, Outside definition to avoid linker error\n\ntemplate \nconst MANIFOLD_TYPE Manifold < SPD, N>::MyType = SPD; \n\ntemplate \nconst int Manifold < SPD, N>::manifold_dim = N * (N + 1) / 2; \n\ntemplate \nconst int Manifold < SPD, N>::value_dim = N * N; \n\ntemplate \nconst bool Manifold < SPD, N>::non_isometric_embedding = true; \n\n\n// Squared SPD distance function\ntemplate \ninline typename Manifold < SPD, N>::dist_type Manifold < SPD, N>::dist_squared( cref_type x, cref_type y ){\n #ifdef TV_SPD_DIST_DEBUG\n\tstd::cout << \"\\nDist2 function with x=\\n\" << x << \"\\nand y=\\n\" << y << std::endl;\n #endif\n// NOTE: If x is not strictly spd, using LDLT completely halts the algorithm\n/* value_type sqrtX = x.sqrt();\n Eigen::LDLT ldlt;\n ldlt.compute(sqrtX);\n\n value_type Z = ldlt.solve(y).transpose();\t\n return ldlt.solve(Z).transpose().log().squaredNorm();\t*/\n value_type invsqrt = x.sqrt().inverse();\n return (invsqrt * y * invsqrt).log().squaredNorm();\n}\n\n\n// Derivative of Squared SPD distance w.r.t. first argument\n// TODO: Switch to solve() for N>4?\ntemplate \ninline void Manifold < SPD, N>::deriv1x_dist_squared( cref_type x, cref_type y, deriv1_ref_type result){\n value_type invsqrt = x.sqrt().inverse();\n result = -2.0 * invsqrt * (invsqrt * y * invsqrt).log() * invsqrt;\n}\n// Derivative of Squared SPD distance w.r.t. second argument\ntemplate \ninline void Manifold < SPD, N>::deriv1y_dist_squared( cref_type x, cref_type y, deriv1_ref_type result){\n deriv1x_dist_squared(y, x, result);\n}\n\n\n// Second Derivative of Squared SPD distance w.r.t first argument\ntemplate \ninline void Manifold < SPD, N>::deriv2xx_dist_squared( cref_type x, cref_type y, deriv2_ref_type result){\n value_type T2, T3, T4;\n T2 = x.sqrt().inverse();\n T3 = T2 * y * T2;\n T4 = T3.log();\n\n deriv2_type dlog, dsqrt;\n KroneckerDLog(T3, dlog);\n KroneckerDSqrt(x, dsqrt);\n\n deriv2_type T2T4tId, IdT2T4, T2T2, T2yId, IdT2y;\n T2T4tId = Eigen::kroneckerProduct(T2 * T4.transpose(), value_type::Identity());\n IdT2T4 = Eigen::kroneckerProduct(value_type::Identity(), T2 * T4);\n T2T2 = Eigen::kroneckerProduct(T2, T2);\n T2yId = Eigen::kroneckerProduct(T2 * y, value_type::Identity());\n IdT2y = Eigen::kroneckerProduct(value_type::Identity(), T2 * y);\n\n result = 2 * (T2T4tId + IdT2T4 + T2T2 * dlog * (T2yId + IdT2y) ) * T2T2 * dsqrt;\n}\n// Second Derivative of Squared SPD distance w.r.t first and second argument\ntemplate \ninline void Manifold < SPD, N>::deriv2xy_dist_squared( cref_type x, cref_type y, deriv2_ref_type result){\n value_type isqrtX, T1;\n isqrtX = x.sqrt().eval().inverse();\n T1 = isqrtX * y * isqrtX;\n\n deriv2_type kp_isqrtX, dlog;\n kp_isqrtX = Eigen::kroneckerProduct(isqrtX, isqrtX);\n KroneckerDLog(T1, dlog);\n\n result = -2 * kp_isqrtX * dlog * kp_isqrtX;\n}\n// Second Derivative of Squared SPD distance w.r.t second argument\ntemplate \ninline void Manifold < SPD, N>::deriv2yy_dist_squared( cref_type x, cref_type y, deriv2_ref_type result){\n deriv2xx_dist_squared(y, x, result);\n}\n\n\n\n// Exponential and Logarithm Map\ntemplate \ntemplate \ninline void Manifold ::exp(const Eigen::MatrixBase& x, const Eigen::MatrixBase& y, Eigen::MatrixBase& result){\n #ifdef TV_SPD_EXP_DEBUG\n\tstd::cout << \"\\nEXP function with x=\\n\" << x << \"\\nand y=\\n\" << y << std::endl;\n #endif\n value_type sqrtX = x.sqrt();\n value_type Z = sqrtX.ldlt().solve(y).transpose();\t\n result = sqrtX * sqrtX.transpose().ldlt().solve(Z).exp() * sqrtX;\t\n}\n\ntemplate \ninline void Manifold ::log(cref_type x, cref_type y, ref_type result){\n #ifdef TV_SPD_LOG_DEBUG\n\tstd::cout << \"\\nLOG function with x=\\n\" << x << \"\\nand y=\\n\" << y << std::endl;\n #endif\n value_type sqrtX = x.sqrt();\n value_type Z = sqrtX.ldlt().solve(y).transpose();\t\n result = sqrtX * sqrtX.transpose().ldlt().solve(Z).log() * sqrtX;\t\n}\n\n// Tangent Plane restriction\ntemplate \ninline void Manifold ::tangent_plane_base(cref_type x, tm_base_ref_type result){\n int d = value_type::RowsAtCompileTime;\n int k = 0;\n \n value_type S, T;\n S = x.sqrt();\n\n for(int i=0; i(T.data(), T.size());\n\t++k;\n }\n\n for(int i=0; i(T.data(), T.size());\n\t ++k;\n\t}\n}\n\ntemplate \ninline void Manifold ::projector(ref_type x){\n // does not exist since SPD is an open set\n // TODO: Eventually implement projection to semi positive definite matrices\n}\n\n// Convex geodesic combinations\ntemplate \ninline void Manifold ::convex_combination(cref_type x, cref_type y, double t, ref_type result){\n value_type l;\n log(x, y, l);\n exp(x, l * t, result);\n}\n\n// Karcher mean implementations\ntemplate \ninline void Manifold::karcher_mean(ref_type x, const value_list& v, double tol, int maxit){\n value_type L, temp;\n \n int k = 0;\n double error = 0.0;\n do{\n\tscalar_type m1 = x.sum();\n\tL = value_type::Zero();\n\tfor(int i = 0; i < v.size(); ++i){\n\t log(x, v[i], temp);\n\t L += temp;\n\t}\n\texp(x, 0.5 / v.size() * (L + L.transpose()), temp);\n\tx = temp;\n\terror = std::abs(x.sum() - m1);\n\t++k;\n } while(error > tol && k < maxit);\n\n}\n\ntemplate \ninline void Manifold::weighted_karcher_mean(ref_type x, const weight_list& w, const value_list& v, double tol, int maxit){\n value_type L, temp;\n \n int k = 0;\n double error = 0.0;\n do{\n\tscalar_type m1 = x.sum();\n\tL = value_type::Zero();\n\tfor(int i = 0; i < v.size(); ++i){\n\t log(x, v[i], temp);\n\t L += w[i] * temp;\n\t}\n\texp(x, 0.5 / v.size() * (L + L.transpose()), temp);\n\tx = temp;\n\terror = std::abs(x.sum() - m1);\n\t++k;\n } while(error > tol && k < maxit);\n\n}\n\ntemplate \ntemplate \ninline void Manifold::karcher_mean(V& x, const Args&... args){\n V temp, sum;\n \n int numArgs = sizeof...(args);\n int k = 0;\n double error = 0.0; \n double tol = 1e-10;\n int maxit = 15;\n do{\n\tscalar_type m1 = x.sum();\n\tsum = x;\n\tvariadic_karcher_mean_gradient(sum, args...);\n\texp(x, 0.5 / numArgs * (sum + sum.transpose()), temp);\n\tx = temp;\n\terror = std::abs(x.sum() - m1);\n\t++k;\n } while(error > tol && k < maxit);\n}\n\ntemplate \ntemplate \ninline void Manifold::variadic_karcher_mean_gradient(V& x, const V& y){\n V temp;\n log(x, y, temp);\n x = temp;\n}\n\ntemplate \ntemplate \ninline void Manifold::variadic_karcher_mean_gradient(V& x, const V& y1, const Args& ... args){\n V temp1, temp2;\n temp2 = x;\n \n log(x, y1, temp1);\n\n variadic_karcher_mean_gradient(temp2, args...);\n temp1 += temp2;\n x = temp1;\n}\n\n\ntemplate \ninline void Manifold::interpolation_preprocessing(ref_type x){\n value_type t = x.log();\n x = t;\n}\n\ntemplate \ninline void Manifold::interpolation_postprocessing(ref_type x){\n value_type t = ( 0.5 * (x + x.transpose()) ).exp();\n x = t;\n}\n\n\n} // end namespace tvmtl\n\n\n\n\n\n\n\n\n#endif\n", "meta": {"hexsha": "8c9bebc1cc33ba368dd51922934834b95e9c6669", "size": 10996, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "mtvmtl/core/manifold_spd.hpp", "max_stars_repo_name": "pdebus/MTVMTL", "max_stars_repo_head_hexsha": "65a7754b34d1f6a1e86d15e3c2d4346b9418414f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2017-05-08T12:40:46.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-02T05:11:01.000Z", "max_issues_repo_path": "mtvmtl/core/manifold_spd.hpp", "max_issues_repo_name": "pdebus/MTVMTL", "max_issues_repo_head_hexsha": "65a7754b34d1f6a1e86d15e3c2d4346b9418414f", "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": "mtvmtl/core/manifold_spd.hpp", "max_forks_repo_name": "pdebus/MTVMTL", "max_forks_repo_head_hexsha": "65a7754b34d1f6a1e86d15e3c2d4346b9418414f", "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.2087912088, "max_line_length": 148, "alphanum_fraction": 0.6777009822, "num_tokens": 3273, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8152324803738429, "lm_q2_score": 0.611381973294151, "lm_q1q2_score": 0.4984184425444453}} {"text": "#include \n#include \n#include \n#include \n\nstruct PoseData {\n Eigen::Vector3d p;\n Eigen::Quaterniond q;\n std::string filename;\n int index;\n};\n\ninline Eigen::Vector3d logmap(const Eigen::Quaterniond &q) {\n Eigen::AngleAxisd aa(q);\n return aa.angle() * aa.axis();\n}\n\ninline std::vector read_7scenes_pose(const std::string &path, int pose_num, const std::string &pose_type) {\n std::vector poses;\n // printf(\"#idx px py pz qx qy qz qw\\n\");\n for (int idx = 0; idx < pose_num; idx++) {\n char filename[1024];\n if (pose_type == \"gt\") {\n sprintf(filename, \"%s/frame-%06d.pose.txt\", path.c_str(), idx);\n } else if (pose_type == \"test\") {\n sprintf(filename, \"%s/frame-%06d.txt\", path.c_str(), idx);\n } else {\n std::runtime_error(\"Unknown pose_type.\");\n }\n std::ifstream in(filename);\n Eigen::Matrix4d e;\n for (int r = 0; r < 4; r++) {\n for (int c = 0; c < 4; c++) {\n in >> e(r, c);\n }\n }\n // origin: Twc\n Eigen::Quaterniond qwc(e.block<3, 3>(0, 0));\n Eigen::Vector3d pwc(e.block<3, 1>(0, 3));\n if (std::abs(qwc.norm() - 1.0) > 1.0e-3) {\n fprintf(stderr, \"Warning, rotation matrix may not be valid, qwc.norm() %.4e\", qwc.norm());\n }\n if (pose_type == \"gt\") {\n pwc.x() += 0.0245;\n } else if (pose_type == \"test\") {\n pwc = -(qwc.conjugate() * pwc);\n qwc = qwc.conjugate();\n } else {\n std::runtime_error(\"Unknown pose_type.\");\n }\n PoseData pose;\n pose.q = qwc;\n pose.p = pwc;\n pose.filename = filename;\n pose.index = idx;\n poses.emplace_back(std::move(pose));\n // printf(\"%05d %.9e %.9e %.9e %.9e %.9e %.9e %.9e\\n\", idx, pwc.x(), pwc.y(), pwc.z(), qwc.x(), qwc.y(), qwc.z(), qwc.w());\n }\n return poses;\n}\n\nint main(int argc, char **argv) {\n std::string gt_dir = argv[1];\n std::string pred_dir = argv[2];\n const int pose_num = 1000;\n auto gt_poses = read_7scenes_pose(gt_dir, pose_num, \"gt\");\n auto pred_poses = read_7scenes_pose(pred_dir, pose_num, \"test\");\n assert(pred_poses.size() == gt_poses.size());\n double APE = 0, ARE = 0, Acount = 0;\n std::vector APEs, AREs;\n for (int i = 0; i < pose_num; ++i) {\n const auto >_pose = gt_poses[i];\n const auto &pred_pose = pred_poses[i];\n Eigen::Vector3d p_error = gt_pose.p - pred_pose.p;\n Eigen::Vector3d q_error = logmap(gt_pose.q.conjugate() * pred_pose.q);\n APE += p_error.squaredNorm();\n ARE += q_error.squaredNorm();\n APEs.push_back(p_error.norm() * 1e3);\n AREs.push_back(q_error.norm() * 180 / M_PI);\n Acount++;\n }\n Acount = std::max(Acount, 1.0);\n APE = std::sqrt(APE / Acount) * 1e3;\n ARE = std::sqrt(ARE / Acount) * 180 / M_PI;\n printf(\"APE RMSE: %.3f [mm]\\nARE RMSE %.3f[DEG]\\n\", APE, ARE);\n std::sort(APEs.begin(), APEs.end());\n std::sort(AREs.begin(), AREs.end());\n printf(\"APE median: %.3f [mm]\\nARE median %.3f[DEG]\\n\", APEs[APEs.size() / 2], AREs[AREs.size() / 2]);\n return 0;\n}\n", "meta": {"hexsha": "7dee6e2b75d3b1b632c5f36d0e25a8d15604f4dd", "size": 3241, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/exec/evaluate_pose.cc", "max_stars_repo_name": "asdiuzd/lass", "max_stars_repo_head_hexsha": "a767f8bd68c46dadf8d74703fdf2058da9f17e53", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-01-06T09:04:46.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-06T09:04:46.000Z", "max_issues_repo_path": "src/exec/evaluate_pose.cc", "max_issues_repo_name": "asdiuzd/lass", "max_issues_repo_head_hexsha": "a767f8bd68c46dadf8d74703fdf2058da9f17e53", "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/exec/evaluate_pose.cc", "max_forks_repo_name": "asdiuzd/lass", "max_forks_repo_head_hexsha": "a767f8bd68c46dadf8d74703fdf2058da9f17e53", "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.6153846154, "max_line_length": 131, "alphanum_fraction": 0.5427337242, "num_tokens": 1017, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920116079209, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.49839821404413404}} {"text": "/*************************************************************************\n\t> File Name: lqr_steer_control.cpp\n\t> Author: TAI Lei\n\t> Mail: ltai@ust.hk\n\t> Created Time: Wed Apr 17 11:48:46 2019\n ************************************************************************/\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"cubic_spline.h\"\n#include \"motion_model.h\"\n#include \"cpprobotics_types.h\"\n\n#define DT 0.1\n#define L 0.5\n#define KP 1.0\n#define MAX_STEER 45.0/180*M_PI\n\nusing namespace cpprobotics;\n\ncv::Point2i cv_offset(\n float x, float y, int image_width=2000, int image_height=2000){\n cv::Point2i output;\n output.x = int(x * 100) + 300;\n output.y = image_height - int(y * 100) - image_height/2;\n return output;\n};\n\nVec_f calc_speed_profile(Vec_f rx, Vec_f ry, Vec_f ryaw, float target_speed){\n\tVec_f speed_profile(ryaw.size(), target_speed);\n\n\tfloat direction = 1.0;\n\tfor(unsigned int i=0; i < ryaw.size()-1; i++){\n\t\tfloat dyaw = std::abs(ryaw[i+1] - ryaw[i]);\n\t\tfloat switch_point = (M_PI/4.0< dyaw) && (dyaw::max();\n\tfor(unsigned int i=0; i= MAX_STEER) delta = MAX_STEER;\n if (delta <= - MAX_STEER) delta = - MAX_STEER;\n\n state.x = state.x + state.v * std::cos(state.yaw) * DT;\n state.y = state.y + state.v * std::sin(state.yaw) * DT;\n state.yaw = state.yaw + state.v / L * std::tan(delta) * DT;\n state.v = state.v + a * DT;\n\n};\n\nvoid closed_loop_prediction(Vec_f cx, Vec_f cy, Vec_f cyaw, Vec_f ck, Vec_f speed_profile, Poi_f goal){\n\tfloat T = 500.0;\n\tfloat goal_dis = 0.5;\n\tfloat stop_speed = 0.05;\n\n\tState state(-0.0, -0.0, 0.0, 0.0);\n\n\tfloat time_ = 0.0;\n\tVec_f x;\n\tx.push_back(state.x);\n\tVec_f y;\n\ty.push_back(state.y);\n\tVec_f yaw;\n\tyaw.push_back(state.yaw);\n\tVec_f v;\n\tv.push_back(state.v);\n\tVec_f t;\n\tt.push_back(0.0);\n\n\tfloat e = 0;\n\tfloat e_th = 0;\n\tint ind = 0;\n\n\n cv::namedWindow(\"lqr\", cv::WINDOW_NORMAL);\n int count = 0;\n\n\n\tcv::Mat bg(2000, 2000, CV_8UC3, cv::Scalar(255, 255, 255));\n\tfor(unsigned int i=1; i= time_){\n\t\tfloat di = lqr_steering_control(state, cx, cy, cyaw, ck, ind, e, e_th);\n\t\tfloat ai = KP * (speed_profile[ind]-state.v);\n\t update(state, ai, di);\n\n\t\tif (std::abs(state.v) <= stop_speed) ind += 1;\n\n\t\tfloat dx = state.x - goal[0];\n\t\tfloat dy = state.y - goal[1];\n\t\tif (std::sqrt(dx*dx + dy*dy) <= goal_dis) {\n\t\t\tstd::cout<<(\"Goal\")< point_ = csp_obj.calc_postion(i);\n\t\tr_x.push_back(point_[0]);\n\t\tr_y.push_back(point_[1]);\n\t\tryaw.push_back(csp_obj.calc_yaw(i));\n\t\trcurvature.push_back(csp_obj.calc_curvature(i));\n\t\trs.push_back(i);\n\t}\n\tfloat target_speed = 10.0 / 3.6;\n\tVec_f speed_profile = calc_speed_profile(r_x, r_y, ryaw, target_speed);\n\tclosed_loop_prediction(r_x, r_y, ryaw, rcurvature, speed_profile, {{wx.back(), wy.back()}});\n\n}", "meta": {"hexsha": "8b1f1632d1854e604784d12c9807f19dd47c46f3", "size": 6027, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/lqr_steer_control.cpp", "max_stars_repo_name": "Singh-sid930/CppRobotics", "max_stars_repo_head_hexsha": "0e4ced2cf1c927156cd3745dee2b2e7250ce95d7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-06-27T07:09:23.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-17T07:54:34.000Z", "max_issues_repo_path": "src/lqr_steer_control.cpp", "max_issues_repo_name": "sweetquiet/CppRobotics", "max_issues_repo_head_hexsha": "c5a8cc9a958ee64ab80b9726dc70a3c11f499bd0", "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/lqr_steer_control.cpp", "max_forks_repo_name": "sweetquiet/CppRobotics", "max_forks_repo_head_hexsha": "c5a8cc9a958ee64ab80b9726dc70a3c11f499bd0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-03-11T13:53:59.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-11T13:53:59.000Z", "avg_line_length": 25.3235294118, "max_line_length": 117, "alphanum_fraction": 0.612742658, "num_tokens": 2148, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920020959544, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.4983982081233217}} {"text": "#define PY_ARRAY_UNIQUE_SYMBOL phist_PyArray_API\n#define NO_IMPORT_ARRAY\n\n#include \n#include \n\n#include \n\n\n#include \n\n\n\n#include \n#include \n\n#include \"seglib/histogram/histogram.hxx\"\n#include \"seglib/histogram/histogram_python.hxx\"\n\n\nnamespace python = boost::python;\n\nnamespace histogram {\n\n\n\n\n vigra::NumpyAnyArray jointColorHistogram(\n\n vigra::NumpyArray<2, vigra::TinyVector > img,\n const vigra::TinyVector & min,\n const vigra::TinyVector & max,\n const vigra::TinyVector & bins,\n const size_t r,\n //output\n vigra::NumpyArray<5, float > res = vigra::NumpyArray<5, float >()\n\n\n ){\n\n // allocate output\n typedef typename vigra::NumpyArray<5, float >::difference_type Shape5;\n Shape5 shape(img.shape(0),img.shape(1),int(bins[0]),int(bins[1]),int(bins[2]));\n res.reshapeIfEmpty(shape);\n std::fill(res.begin(),res.end(),0.0);\n // \n Shape5 histCoord;\n const vigra::TinyVector ones(1,1,1);\n const vigra::TinyVector radius(r,r);\n const vigra::TinyVector radius1(r+1,r+1);\n const vigra::TinyVector fac = ( (bins-ones) / (max-min) );\n\n\n vigra::TinyVector start,end,c;\n\n for(histCoord[0]=0;histCoord[0] pixelValue = img(c[0],c[1]);\n pixelValue -= min;\n pixelValue *= fac;\n\n // (the first two coordinates of hist coord are filled)\n histCoord[2]=int(pixelValue[0]);\n histCoord[3]=int(pixelValue[1]);\n histCoord[4]=int(pixelValue[2]);\n\n\n PHIST_ASSERT_OP(histCoord[0],<,img.shape(0));\n PHIST_ASSERT_OP(histCoord[1],<,img.shape(1));\n\n PHIST_ASSERT_OP(histCoord[2],<,bins[0]);\n PHIST_ASSERT_OP(histCoord[3],<,bins[1]);\n PHIST_ASSERT_OP(histCoord[4],<,bins[2]);\n\n // increment counter\n res(histCoord[0],histCoord[1],histCoord[2],histCoord[3],histCoord[4])+=1.0;\n } \n } \n\n // normalizes\n for(histCoord[0]=0;histCoord[0] > img,\n vigra::NumpyArray<1, float > min,\n vigra::NumpyArray<1, float > max,\n const size_t bins,\n const size_t r,\n //output\n vigra::NumpyArray<4, float > res = vigra::NumpyArray<4, float >()\n ){ \n const size_t nChannels=img.shape(2);\n // allocate output\n typedef typename vigra::NumpyArray<4, float >::difference_type Shape4;\n Shape4 shape(img.shape(0),img.shape(1),nChannels,bins);\n res.reshapeIfEmpty(shape);\n std::fill(res.begin(),res.end(),0.0);\n\n\n // coordinate in the res array (pixel wise histogram)\n // (x,y,c,bin)\n Shape4 histCoord;\n const vigra::TinyVector radius1(r+1,r+1);\n // channel wise factor\n std::vector fac(nChannels);\n for(size_t channel=0;channel start,end,c;\n\n for(histCoord[0]=0;histCoord[0]((value - min(histCoord[2]) )*fac[histCoord[2]]);\n\n /*\n std::cout<<\"\\n\\n” channel \"< > img,\n // input labeling for which are used as mask images\n vigra::NumpyArray<3, vigra::Multiband > labelings,\n vigra::NumpyArray<1, UInt64> numberOfLabels,\n vigra::NumpyArray<1, float> weights\n ){\n\n const size_t numberOfInputLabelings = labelings.shape(2);\n \n }\n */\n\n\n void export_histogram(){\n\n python::def(\"_jointColorHistogram_\",vigra::registerConverters(&jointColorHistogram),\n (\n python::arg(\"img\"),\n python::arg(\"dmin\"),\n python::arg(\"dmax\"),\n python::arg(\"bins\"),\n python::arg(\"r\"),\n python::arg(\"out\")=python::object()\n )\n );\n\n python::def(\"_batchHistogram_\",vigra::registerConverters(&batchHistogram),\n (\n python::arg(\"img\"),\n python::arg(\"dmin\"),\n python::arg(\"dmax\"),\n python::arg(\"bins\"),\n python::arg(\"r\"),\n python::arg(\"out\")=python::object()\n )\n );\n\n }\n\n}", "meta": {"hexsha": "7bb18c1d689668ebf2d99fa8e94f04d6fb3a3297", "size": 8237, "ext": "cxx", "lang": "C++", "max_stars_repo_path": "src/python/histogram/py_histogram.cxx", "max_stars_repo_name": "DerThorsten/seglib", "max_stars_repo_head_hexsha": "4655079e390e301dd93e53f5beed6c9737d6df9f", "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/python/histogram/py_histogram.cxx", "max_issues_repo_name": "DerThorsten/seglib", "max_issues_repo_head_hexsha": "4655079e390e301dd93e53f5beed6c9737d6df9f", "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/python/histogram/py_histogram.cxx", "max_forks_repo_name": "DerThorsten/seglib", "max_forks_repo_head_hexsha": "4655079e390e301dd93e53f5beed6c9737d6df9f", "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.0803212851, "max_line_length": 100, "alphanum_fraction": 0.5108656064, "num_tokens": 2252, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920020959544, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.4983982081233217}} {"text": "// Copyright (c) 2020-2021 Franz Alt\n// This code is licensed under MIT license (see LICENSE.txt for details).\n\n#include \n\n#include \n#include \n#include \n#include \n\n#include \n\nnamespace {\n\ntemplate\ncvpg::histogram calc_hog_cell(std::shared_ptr image, std::size_t from_x, std::size_t to_x, std::size_t from_y, std::size_t to_y, bool l1_normalilze = true);\n\ntemplate<>\ncvpg::histogram calc_hog_cell(std::shared_ptr image, std::size_t from_x, std::size_t to_x, std::size_t from_y, std::size_t to_y, bool l1_normalize)\n{\n cvpg::histogram histogram(9);\n\n const std::uint8_t * raw = image->data(0).get();\n const std::size_t image_width = image->width();\n\n std::int16_t gx = 0;\n std::int16_t gy = 0;\n double mag = 0.0;\n double angle = 0.0;\n\n // correct from/to-values to calculate the gradients up to the image borders\n if (from_x > 1)\n {\n --from_x;\n }\n else\n {\n from_x = 1;\n }\n\n if (to_x < (image->width() - 2))\n {\n ++to_x;\n }\n else\n {\n to_x = image->width() - 2;\n }\n\n if (from_y > 1)\n {\n --from_y;\n }\n else\n {\n from_y = 1;\n }\n\n if (to_y < (image->height() - 2))\n {\n ++to_y;\n }\n else\n {\n to_y = image->height() - 2;\n }\n\n for (std::size_t y = from_y; y <= to_y; ++y)\n {\n for (std::size_t x = from_x; x <= to_x; ++x)\n {\n // calculate the x/y gradients\n gx = static_cast(raw[y * image_width + (x + 1)]) - static_cast(raw[y * image_width + (x - 1)]);\n gy = static_cast(raw[(y + 1) * image_width + x]) - static_cast(raw[(y - 1) * image_width + x]);\n\n // calculate the gradient magnitude\n mag = std::sqrt(static_cast(gx * gx + gy * gy));\n\n // calculate the absolute gradient angle\n angle = std::fabs((gx == 0) ? 0.0 : atan(static_cast(gy) / static_cast(gx)) * 180.0 / M_PI);\n\n const std::size_t bin = static_cast(std::floor(angle / 20.0));\n\n histogram.at(bin) += static_cast(mag);\n }\n }\n\n cvpg::histogram normalized_histogram(9);\n\n if (l1_normalize)\n {\n // normalize histogram (L1 norm)\n double sum = 0;\n\n for (auto const & h : histogram)\n {\n sum += std::fabs(static_cast(h));\n }\n\n for (std::size_t i = 0; i < histogram.bins(); ++i)\n {\n normalized_histogram.at(i) = static_cast(histogram.at(i)) / sum;\n }\n }\n else\n {\n // normalize histogram (L2 norm)\n double sum = 0;\n\n for (auto const & h : histogram)\n {\n auto h_ = std::fabs(static_cast(h));\n sum += h_ * h_;\n }\n\n sum = std::sqrt(sum);\n\n for (std::size_t i = 0; i < histogram.bins(); ++i)\n {\n normalized_histogram.at(i) = std::min(1.0, static_cast(histogram.at(i)) / sum);\n }\n }\n\n return normalized_histogram;\n}\n\ntemplate<>\ncvpg::histogram calc_hog_cell(std::shared_ptr image, std::size_t from_x, std::size_t to_x, std::size_t from_y, std::size_t to_y, bool l1_normalize)\n{\n // TODO implement me!\n\n return cvpg::histogram(9);\n}\n\ntemplate\nstruct hog_col_task : public boost::asynchronous::continuation_task > >\n{\n hog_col_task(std::shared_ptr image, std::size_t from_x, std::size_t to_x, std::size_t from_y, std::size_t to_y, std::size_t cell_dimension, std::size_t sequential_cells_per_row)\n : boost::asynchronous::continuation_task > >(\"hog_col\")\n , m_image(image)\n , m_from_x(from_x)\n , m_to_x(to_x)\n , m_from_y(from_y)\n , m_to_y(to_y)\n , m_cell_dimension(cell_dimension)\n , m_sequential_cells_per_row(sequential_cells_per_row)\n {}\n\n void operator()()\n {\n auto task_res = this->this_task_result();\n\n const std::size_t cells = (m_to_x - m_from_x + 1) / m_cell_dimension;\n\n if (cells <= m_sequential_cells_per_row)\n {\n std::vector > hogs;\n hogs.reserve(cells);\n\n for (std::size_t i = 0; i < cells; ++i)\n {\n hogs.push_back(calc_hog_cell(m_image, m_from_x + i * m_cell_dimension, m_from_x + (i + 1) * m_cell_dimension - 1, m_from_y, m_to_y));\n }\n\n task_res.set_value(std::move(hogs));\n }\n else\n {\n // determine middle of x-range dependet on the cell dimension\n const std::size_t x_half = m_from_x + (cells / 2) * m_cell_dimension;\n\n boost::asynchronous::create_callback_continuation(\n [task_res = std::move(task_res)](auto cont_res) mutable\n {\n try\n {\n auto h = std::move(std::get<1>(cont_res).get());\n\n std::vector > hogs(std::move(std::get<0>(cont_res).get()));\n hogs.insert(hogs.end(), h.begin(), h.end());\n\n task_res.set_value(std::move(hogs));\n }\n catch (...)\n {\n task_res.set_exception(std::current_exception());\n }\n },\n hog_col_task(m_image, m_from_x, x_half - 1, m_from_y, m_to_y, m_cell_dimension, m_sequential_cells_per_row),\n hog_col_task(m_image, x_half, m_to_x, m_from_y, m_to_y, m_cell_dimension, m_sequential_cells_per_row)\n );\n }\n }\n\nprivate:\n std::shared_ptr m_image;\n\n std::size_t m_from_x;\n std::size_t m_to_x;\n std::size_t m_from_y;\n std::size_t m_to_y;\n\n std::size_t m_cell_dimension;\n\n std::size_t m_sequential_cells_per_row;\n};\n\ntemplate\nstruct hog_row_task : public boost::asynchronous::continuation_task > >\n{\n hog_row_task(std::shared_ptr image, std::size_t from_x, std::size_t to_x, std::size_t from_y, std::size_t to_y, std::size_t cell_dimension, std::size_t sequential_cells_per_row)\n : boost::asynchronous::continuation_task > >(\"hog_row\")\n , m_image(image)\n , m_from_x(from_x)\n , m_to_x(to_x)\n , m_from_y(from_y)\n , m_to_y(to_y)\n , m_cell_dimension(cell_dimension)\n , m_sequential_cells_per_row(sequential_cells_per_row)\n {}\n\n void operator()()\n {\n auto task_res = this->this_task_result();\n\n const std::size_t cells = (m_to_y - m_from_y + 1) / m_cell_dimension;\n\n if (cells <= 1)\n {\n boost::asynchronous::create_callback_continuation(\n [task_res = std::move(task_res)](auto cont_res) mutable\n {\n try\n {\n task_res.set_value(std::move(std::get<0>(cont_res).get()));\n }\n catch (...)\n {\n task_res.set_exception(std::current_exception());\n }\n },\n hog_col_task(m_image, m_from_x, m_to_x, m_from_y, m_to_y, m_cell_dimension, m_sequential_cells_per_row)\n );\n }\n else\n {\n // determine middle of y-range dependet on the cell dimension\n const std::size_t y_half = m_from_y + (cells / 2) * m_cell_dimension;\n\n boost::asynchronous::create_callback_continuation(\n [task_res = std::move(task_res)](auto cont_res) mutable\n {\n try\n {\n auto h = std::move(std::get<1>(cont_res).get());\n\n std::vector > hogs(std::move(std::get<0>(cont_res).get()));\n hogs.insert(hogs.end(), h.begin(), h.end());\n\n task_res.set_value(std::move(hogs));\n }\n catch (...)\n {\n task_res.set_exception(std::current_exception());\n }\n },\n hog_row_task(m_image, m_from_x, m_to_x, m_from_y, y_half - 1, m_cell_dimension, m_sequential_cells_per_row),\n hog_row_task(m_image, m_from_x, m_to_x, y_half, m_to_y, m_cell_dimension, m_sequential_cells_per_row)\n );\n }\n }\n\nprivate:\n std::shared_ptr m_image;\n\n std::size_t m_from_x;\n std::size_t m_to_x;\n std::size_t m_from_y;\n std::size_t m_to_y;\n\n std::size_t m_cell_dimension;\n\n std::size_t m_sequential_cells_per_row;\n};\n\ntemplate\nstruct hog_task : public boost::asynchronous::continuation_task > >\n{\n hog_task(image_type image, std::size_t cell_dimension, std::size_t sequential_cells_per_row = 4)\n : boost::asynchronous::continuation_task > >(\"hog\")\n , m_image(std::make_shared(std::forward(image)))\n , m_cell_dimension(cell_dimension)\n , m_sequential_cells_per_row(sequential_cells_per_row)\n {}\n\n void operator()()\n {\n auto task_res = this->this_task_result();\n\n // determine the amount of rows and columns dependent on the desired cell dimension\n const std::size_t cols = m_image->width() / m_cell_dimension;\n const std::size_t rows = m_image->height() / m_cell_dimension;\n\n boost::asynchronous::create_callback_continuation(\n [task_res = std::move(task_res)](auto cont_res) mutable\n {\n try\n {\n task_res.set_value(std::move(std::get<0>(cont_res).get()));\n }\n catch (...)\n {\n task_res.set_exception(std::current_exception());\n }\n },\n hog_row_task(m_image, 0, m_image->width() - 1, 0, m_image->height() - 1, m_cell_dimension, m_sequential_cells_per_row)\n );\n }\n\nprivate:\n std::shared_ptr m_image;\n\n std::size_t m_cell_dimension;\n\n std::size_t m_sequential_cells_per_row;\n};\n\nvoid paint_hog_cell(std::shared_ptr image, cvpg::histogram const & histogram, std::size_t from_x, std::size_t to_x, std::size_t from_y, std::size_t to_y)\n{\n auto raw = image->data(0).get();\n const std::size_t image_width = image->width();\n\n const std::size_t half_x = from_x + (to_x - from_x) / 2;\n const std::size_t half_y = from_y + (to_y - from_y) / 2;\n\n auto draw_line_from_center =\n [raw, image_width, h_x = half_x, h_y = half_y](std::int32_t dx, std::int32_t dy, double increment)\n {\n // calculate start point\n const std::int32_t x_s = h_x - abs(dx);\n const std::int32_t y_s = h_y - abs(dy);\n\n // calculate end point\n const std::int32_t x_e = h_x + abs(dx);\n const std::int32_t y_e = h_y + abs(dy);\n\n if (abs(dx) > abs(dy))\n {\n // calculate the slope of the line\n const std::int32_t s = dy / dx;\n\n std::size_t y = y_s;\n\n for (std::size_t x = x_s; x <= x_e; ++x, y += s)\n {\n std::uint8_t * r = raw + y * image_width + x;\n\n *r = std::min(\n static_cast(255),\n static_cast(*r + increment * 255.0)\n );\n }\n }\n else\n {\n // calculate the slope of the line\n const std::int32_t s = dx / dy;\n\n std::size_t x = x_s;\n\n for (std::size_t y = y_s; y <= y_e; ++y, x += s)\n {\n std::uint8_t * r = raw + y * image_width + x;\n\n *r = std::min(\n static_cast(255),\n static_cast(*r + increment * 255.0)\n );\n }\n }\n };\n\n for (std::size_t i = 0; i < histogram.bins(); ++i)\n {\n auto const & h = histogram.at(i);\n\n if (h != 0.0)\n {\n if (i == 0)\n {\n // case: angle is at range [0..20) degree\n draw_line_from_center(0, 2, h);\n }\n else if (i == 1)\n {\n // case: angle it at range [20..40) degree\n draw_line_from_center(1, 2, h);\n }\n else if (i == 2)\n {\n // case: angle it at range [40..60) degree\n draw_line_from_center(2, 2, h);\n }\n else if (i == 3)\n {\n // case: angle it at range [60..80) degree\n draw_line_from_center(2, 1, h);\n }\n else if (i == 4)\n {\n // case: angle it at range [80..100) degree\n draw_line_from_center(2, 0, h);\n }\n else if (i == 5)\n {\n // case: angle it at range [100..120) degree\n draw_line_from_center(2, -1, h);\n }\n else if (i == 6)\n {\n // case: angle it at range [120..140) degree\n draw_line_from_center(2, -2, h);\n }\n else if (i == 7)\n {\n // case: angle it at range [140..160) degree\n draw_line_from_center(1, -2, h);\n }\n else if (i == 8)\n {\n // case: angle it at range [160..180) degree\n draw_line_from_center(0, -2, h);\n }\n }\n }\n}\n\nstruct hog_image_col_task : public boost::asynchronous::continuation_task\n{\n hog_image_col_task(std::shared_ptr image, std::shared_ptr > > histograms, std::size_t from_cell_col, std::size_t to_cell_col, std::size_t from_cell_row, std::size_t to_cell_row, std::size_t cell_dimension)\n : boost::asynchronous::continuation_task(\"hog_image_col\")\n , m_image(std::move(image))\n , m_histograms(std::move(histograms))\n , m_from_cell_col(from_cell_col)\n , m_to_cell_col(to_cell_col)\n , m_from_cell_row(from_cell_row)\n , m_to_cell_row(to_cell_row)\n , m_cell_dimension(cell_dimension)\n {}\n\n void operator()()\n {\n auto task_res = this->this_task_result();\n\n const std::size_t cells = m_to_cell_col - m_from_cell_col + 1;\n\n if (cells <= 1)\n {\n const std::size_t cells_per_row = m_image->width() / m_cell_dimension;\n\n // determine histogram for current cell\n cvpg::histogram const & h = m_histograms->at(m_from_cell_row * cells_per_row + m_from_cell_col);\n\n const std::size_t from_x = m_from_cell_col * m_cell_dimension;\n const std::size_t to_x = from_x + m_cell_dimension - 1;\n const std::size_t from_y = m_from_cell_row * m_cell_dimension;\n const std::size_t to_y = from_y + m_cell_dimension - 1;\n\n paint_hog_cell(m_image, h, from_x, to_x, from_y, to_y);\n\n task_res.set_value();\n }\n else\n {\n // determine middle of col-range\n const std::size_t col_half = m_from_cell_col + (cells / 2);\n\n boost::asynchronous::create_callback_continuation(\n [task_res = std::move(task_res)](auto cont_res) mutable\n {\n try\n {\n std::get<0>(cont_res).get();\n std::get<1>(cont_res).get();\n\n task_res.set_value();\n }\n catch (...)\n {\n task_res.set_exception(std::current_exception());\n }\n },\n hog_image_col_task(m_image, m_histograms, m_from_cell_col, col_half - 1, m_from_cell_row, m_to_cell_row, m_cell_dimension),\n hog_image_col_task(m_image, m_histograms, col_half, m_to_cell_col, m_from_cell_row, m_to_cell_row, m_cell_dimension)\n );\n }\n }\n\nprivate:\n std::shared_ptr m_image;\n\n std::shared_ptr > > m_histograms;\n\n std::size_t m_from_cell_col;\n std::size_t m_to_cell_col;\n std::size_t m_from_cell_row;\n std::size_t m_to_cell_row;\n\n std::size_t m_cell_dimension;\n};\n\nstruct hog_image_row_task : public boost::asynchronous::continuation_task\n{\n hog_image_row_task(std::shared_ptr image, std::shared_ptr > > histograms, std::size_t from_cell_col, std::size_t to_cell_col, std::size_t from_cell_row, std::size_t to_cell_row, std::size_t cell_dimension)\n : boost::asynchronous::continuation_task(\"hog_image_row\")\n , m_image(std::move(image))\n , m_histograms(std::move(histograms))\n , m_from_cell_col(from_cell_col)\n , m_to_cell_col(to_cell_col)\n , m_from_cell_row(from_cell_row)\n , m_to_cell_row(to_cell_row)\n , m_cell_dimension(cell_dimension)\n {}\n\n void operator()()\n {\n auto task_res = this->this_task_result();\n\n const std::size_t cells = m_to_cell_row - m_from_cell_row + 1;\n\n if (cells <= 1)\n {\n boost::asynchronous::create_callback_continuation(\n [task_res = std::move(task_res)](auto cont_res) mutable\n {\n try\n {\n std::get<0>(cont_res).get();\n\n task_res.set_value();\n }\n catch (...)\n {\n task_res.set_exception(std::current_exception());\n }\n },\n hog_image_col_task(m_image, m_histograms, m_from_cell_col, m_to_cell_col, m_from_cell_row, m_to_cell_row, m_cell_dimension)\n );\n }\n else\n {\n // determine middle of row-range\n const std::size_t row_half = m_from_cell_row + (cells / 2);\n\n boost::asynchronous::create_callback_continuation(\n [task_res = std::move(task_res)](auto cont_res) mutable\n {\n try\n {\n std::get<0>(cont_res).get();\n std::get<1>(cont_res).get();\n\n task_res.set_value();\n }\n catch (...)\n {\n task_res.set_exception(std::current_exception());\n }\n },\n hog_image_row_task(m_image, m_histograms, m_from_cell_col, m_to_cell_col, m_from_cell_row, row_half - 1, m_cell_dimension),\n hog_image_row_task(m_image, m_histograms, m_from_cell_col, m_to_cell_col, row_half, m_to_cell_row, m_cell_dimension)\n );\n }\n }\n\nprivate:\n std::shared_ptr m_image;\n\n std::shared_ptr > > m_histograms;\n\n std::size_t m_from_cell_col;\n std::size_t m_to_cell_col;\n std::size_t m_from_cell_row;\n std::size_t m_to_cell_row;\n\n std::size_t m_cell_dimension;\n};\n\nstruct hog_image_task : public boost::asynchronous::continuation_task\n{\n hog_image_task(std::vector > histograms, std::size_t cells_per_row, std::size_t cell_dimension)\n : boost::asynchronous::continuation_task(\"hog_image\")\n , m_histograms(std::make_shared > >(std::move(histograms)))\n , m_cells_per_row(cells_per_row)\n , m_cell_dimension(cell_dimension)\n {}\n\n void operator()()\n {\n auto task_res = this->this_task_result();\n\n const std::size_t cell_cols = m_cells_per_row;\n const std::size_t cell_rows = m_histograms->size() / cell_cols;\n\n // create a result image ...\n auto image = std::make_shared(cell_cols * m_cell_dimension, cell_rows * m_cell_dimension);\n\n // ... and paint it black\n memset(image->data(0).get(), 0, image->width() * image->height());\n\n boost::asynchronous::create_callback_continuation(\n [task_res = std::move(task_res), image](auto cont_res) mutable\n {\n try\n {\n std::get<0>(cont_res).get();\n\n task_res.set_value(std::move(*image));\n }\n catch (...)\n {\n task_res.set_exception(std::current_exception());\n }\n },\n hog_image_row_task(image, m_histograms, 0, cell_cols - 1, 0, cell_rows - 1, m_cell_dimension)\n );\n }\n\nprivate:\n std::shared_ptr > > m_histograms;\n\n std::size_t m_cells_per_row;\n\n std::size_t m_cell_dimension;\n};\n\n}\n\nnamespace cvpg::imageproc::algorithms {\n\nboost::asynchronous::detail::callback_continuation > > hog(image_gray_8bit image, std::size_t cell_dimension)\n{\n return boost::asynchronous::top_level_callback_continuation > >(\n hog_task(std::move(image), cell_dimension)\n );\n}\n\nboost::asynchronous::detail::callback_continuation > > hog(image_rgb_8bit image, std::size_t cell_dimension)\n{\n return boost::asynchronous::top_level_callback_continuation > >(\n hog_task(std::move(image), cell_dimension)\n );\n}\n\nboost::asynchronous::detail::callback_continuation hog_image(std::vector > histograms, std::size_t cells_per_row, std::size_t cell_dimension)\n{\n return boost::asynchronous::top_level_callback_continuation(\n hog_image_task(std::move(histograms), cells_per_row, cell_dimension)\n );\n}\n\nboost::asynchronous::detail::callback_continuation hog_image(image_gray_8bit image)\n{\n const std::size_t cell_dimension = 8;\n\n auto cells_per_row = image.width() / cell_dimension;\n\n return boost::asynchronous::then(\n hog(std::move(image), cell_dimension),\n [cells_per_row, cell_dimension](auto cont_res)\n {\n return hog_image(std::move(cont_res.get()), cells_per_row, cell_dimension);\n }\n );\n}\n\nboost::asynchronous::detail::callback_continuation hog_image(image_rgb_8bit image)\n{\n const std::size_t cell_dimension = 8;\n\n auto cells_per_row = image.width() / cell_dimension;\n\n return boost::asynchronous::then(\n hog(std::move(image), cell_dimension),\n [cells_per_row, cell_dimension](auto cont_res)\n {\n return hog_image(std::move(cont_res.get()), cells_per_row, cell_dimension);\n }\n );\n}\n\n} // namespace cvpg::imageproc::algorithms\n", "meta": {"hexsha": "2cf4c3018e55b16e995e786def0c9ecbf4277536", "size": 23784, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/libcvpg/imageproc/algorithms/hog.cpp", "max_stars_repo_name": "franz-alt/cv-playground", "max_stars_repo_head_hexsha": "d6c3bbdb500bf121c28299d117e459730b2b912d", "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/libcvpg/imageproc/algorithms/hog.cpp", "max_issues_repo_name": "franz-alt/cv-playground", "max_issues_repo_head_hexsha": "d6c3bbdb500bf121c28299d117e459730b2b912d", "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/libcvpg/imageproc/algorithms/hog.cpp", "max_forks_repo_name": "franz-alt/cv-playground", "max_forks_repo_head_hexsha": "d6c3bbdb500bf121c28299d117e459730b2b912d", "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.3203463203, "max_line_length": 268, "alphanum_fraction": 0.5598301379, "num_tokens": 5848, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835452961427, "lm_q2_score": 0.5964331462646254, "lm_q1q2_score": 0.49831007957330203}} {"text": "// Copyright Yamaha 2021\n// MIT License\n// https://github.com/yamaha-bps/cbr_control/blob/master/LICENSE\n\n#ifndef CBR_CONTROL__MPC__DLTV_OCP_HPP_\n#define CBR_CONTROL__MPC__DLTV_OCP_HPP_\n\n#include \n\n#include \n\n#include \n\n#include \"ocp_common.hpp\"\n\nnamespace cbr\n{\n\n/* ---------------------------------------------------------------------------------------------- */\n/* Continuous Time Varying Linear Optimal Control Problem Discretizer */\n/* ---------------------------------------------------------------------------------------------- */\n\ntemplate\nclass DltvOcp\n{\npublic:\n // Must be defined in ctlv_pb problem\n constexpr static std::size_t nx = cltv_pb_t::nx;\n constexpr static std::size_t nu = cltv_pb_t::nu;\n constexpr static std::size_t nPts = _nPts;\n\n using problem_t = cltv_pb_t;\n\n // Create some useful aliases\n using state_t = Eigen::Matrix;\n using input_t = Eigen::Matrix;\n using time_t = Eigen::Matrix;\n using A_t = Eigen::Matrix;\n using B_t = Eigen::Matrix;\n using Q_t = Eigen::Matrix;\n using R_t = Eigen::Matrix;\n\n // Get return type of problem functions\n using Ar_t = std::result_of_t;\n using Br_t = std::result_of_t;\n using Qr_t = std::result_of_t;\n using QTr_t = std::result_of_t;\n using Rr_t = std::result_of_t;\n\n /* -------------------------------------------------------------------------- */\n /* Optionals */\n /* -------------------------------------------------------------------------- */\n\n // Check existance of get_E function\n constexpr static bool has_E_approx = std::experimental::is_detected_v<\n ocp_detail::has_E_continuous, cltv_pb_t>;\n constexpr static bool has_E = std::experimental::is_detected_exact_v<\n state_t, ocp_detail::has_E_continuous, cltv_pb_t>||\n std::experimental::is_detected_exact_v<\n const state_t &, ocp_detail::has_E_continuous, cltv_pb_t>;\n using Er_t = std::experimental::detected_or_t<\n state_t, ocp_detail::has_E_continuous, cltv_pb_t>;\n static_assert(\n !(has_E_approx && !has_E),\n \"Detected get_E function doesn't have a correct return type. \"\n \"It must be an nx*1 Eigen::Matrix (or a const reference to one)\");\n\n // Check existance of get_q function\n constexpr static bool has_q_approx = std::experimental::is_detected_v<\n ocp_detail::has_q_continuous, cltv_pb_t>;\n constexpr static bool has_q = std::experimental::is_detected_exact_v<\n state_t, ocp_detail::has_q_continuous, cltv_pb_t>||\n std::experimental::is_detected_exact_v<\n const state_t &, ocp_detail::has_q_continuous, cltv_pb_t>;\n using qr_t = std::experimental::detected_or_t<\n state_t, ocp_detail::has_q_continuous, cltv_pb_t>;\n static_assert(\n !(has_q_approx && !has_q),\n \"Detected get_q function doesn't have a correct return type. \"\n \"It must be an nx*1 Eigen::Matrix (or a const reference to one)\");\n\n // Check existance of get_qT function\n constexpr static bool has_qT_approx = std::experimental::is_detected_v<\n ocp_detail::has_qT_continuous, cltv_pb_t>;\n constexpr static bool has_qT = std::experimental::is_detected_exact_v<\n state_t, ocp_detail::has_qT_continuous, cltv_pb_t>||\n std::experimental::is_detected_exact_v<\n const state_t &, ocp_detail::has_qT_continuous, cltv_pb_t>;\n\n using qTr_t = std::experimental::detected_or_t<\n state_t, ocp_detail::has_qT_continuous, cltv_pb_t>; \\\n static_assert(\n !(has_qT_approx && !has_qT),\n \"Detected get_qT function doesn't have a correct return type. \"\n \"It must be an nx*1 Eigen::Matrix (or a const reference to one)\");\n\n // Check existance of get_r function\n constexpr static bool has_r_approx = std::experimental::is_detected_v<\n ocp_detail::has_r_continuous, cltv_pb_t>;\n constexpr static bool has_r = std::experimental::is_detected_exact_v<\n input_t, ocp_detail::has_r_continuous, cltv_pb_t>||\n std::experimental::is_detected_exact_v<\n const input_t &, ocp_detail::has_r_continuous, cltv_pb_t>;\n using rr_t = std::experimental::detected_or_t<\n input_t, ocp_detail::has_r_continuous, cltv_pb_t>;\n static_assert(\n !(has_r_approx && !has_r),\n \"Detected get_r function doesn't have a correct return type. \"\n \"It must be an nu*1 Eigen::Matrix (or a const reference to one)\");\n\n // Check problem dimensions\n static_assert(nx > 0, \"Number of states must be > 0.\");\n static_assert(nu > 0, \"Number of inputs must be > 0.\");\n static_assert(nPts > 1, \"Number of trajectory points must be > 1.\");\n static_assert(exp_order < 20, \"Exponential order must be < 20.\");\n\n // Check return type of problem functions\n static_assert(\n std::is_same_v, A_t>,\n \"The get_A method of the problem must return an nx*nx Eigen::Matrix (or a reference to one).\");\n static_assert(\n std::is_same_v, B_t>,\n \"The get_B method of the problem must return an nx*nu Eigen::Matrix (or a reference to one).\");\n static_assert(\n std::is_same_v, Q_t>,\n \"The get_Q method of the problem must return an nx*nx Eigen::Matrix (or a reference to one).\");\n static_assert(\n std::is_same_v, state_t>,\n \"The get_q method of the problem must return an nx*1 Eigen::Matrix (or a reference to one).\");\n static_assert(\n std::is_same_v, Q_t>,\n \"The get_QT method of the problem must return an nx*nx Eigen::Matrix (or a reference to one).\");\n static_assert(\n std::is_same_v, state_t>,\n \"The get_qT method of the problem must return an nx*1 Eigen::Matrix (or a reference to one).\");\n static_assert(\n std::is_same_v, R_t>,\n \"The get_R method of the problem must return an nu*nu Eigen::Matrix (or a reference to one).\");\n static_assert(\n std::is_same_v, input_t>,\n \"The get_r method of the problem must return an nu*1 Eigen::Matrix (or a reference to one).\");\n\npublic:\n DltvOcp() = delete;\n DltvOcp(const DltvOcp &) = default;\n DltvOcp(DltvOcp &&) = default;\n DltvOcp & operator=(const DltvOcp &) = default;\n DltvOcp & operator=(DltvOcp &&) = default;\n\n explicit DltvOcp(const cltv_pb_t & pb)\n : cltv_pb_(pb),\n dt_{compute_dt()}\n {}\n\n explicit DltvOcp(cltv_pb_t && pb)\n : cltv_pb_(std::move(pb)),\n dt_{compute_dt()}\n {}\n\n template\n DltvOcp(T1 && pb)\n : cltv_pb_(std::forward(pb)),\n dt_{compute_dt()}\n {}\n\n void get_x0(Eigen::Ref x0) const\n {\n cltv_pb_.get_x0(x0);\n }\n\n void get_state_lb(std::size_t k, Eigen::Ref state_lb) const\n {\n cltv_pb_.get_state_lb(indexToTime(k), state_lb);\n }\n\n void get_state_ub(std::size_t k, Eigen::Ref state_ub) const\n {\n cltv_pb_.get_state_ub(indexToTime(k), state_ub);\n }\n\n void get_input_lb(std::size_t k, Eigen::Ref input_lb) const\n {\n cltv_pb_.get_input_lb(indexToTime(k), input_lb);\n }\n\n void get_input_ub(std::size_t k, Eigen::Ref input_ub) const\n {\n cltv_pb_.get_input_ub(indexToTime(k), input_ub);\n }\n\n A_t get_A(std::size_t k) const\n {\n // define identity for order = 0\n A_t expA = A_t::Identity();\n\n if constexpr (exp_order > 0) {\n const A_t Adt = dt_ * cltv_pb_.get_A(indexToTime(k));\n expA += Adt;\n if constexpr (exp_order > 1) {\n double c = 1.;\n A_t Adtp = Adt;\n for (std::size_t i = 2; i <= exp_order; i++) {\n Adtp *= Adt;\n c /= static_cast(i);\n expA += c * Adtp;\n }\n }\n }\n\n return expA;\n }\n\n B_t get_B(std::size_t k) const\n {\n // define identity for order = 0\n A_t expA = A_t::Identity();\n\n if constexpr (exp_order > 0) {\n const A_t Adt = dt_ * cltv_pb_.get_A(indexToTime(k));\n expA += Adt / 2.;\n if constexpr (exp_order > 1) {\n double c = 0.5;\n A_t Adtp = Adt / 2.;\n for (std::size_t i = 2; i <= exp_order; i++) {\n Adtp *= Adt;\n c /= static_cast(i + 1);\n expA += c * Adtp;\n }\n }\n }\n\n B_t expB = expA * cltv_pb_.get_B(indexToTime(k)) * dt_;\n\n return expB;\n }\n\n template\n state_t get_E(std::enable_if_t k)\n {\n // define identity for order = 0\n A_t expA = A_t::Identity();\n\n if constexpr (exp_order > 0) {\n const A_t Adt = dt_ * cltv_pb_.get_A(indexToTime(k));\n expA += Adt / 2.;\n if constexpr (exp_order > 1) {\n double c = 0.5;\n A_t Adtp = Adt / 2.;\n for (std::size_t i = 2; i <= exp_order; i++) {\n Adtp *= Adt;\n c /= static_cast(i + 1);\n expA += c * Adtp;\n }\n }\n }\n\n state_t expE = expA * cltv_pb_.get_E(indexToTime(k)) * dt_;\n return expE;\n }\n\n Q_t get_Q(std::size_t k) const\n {\n return dt_ * cltv_pb_.get_Q(indexToTime(k));\n }\n\n template\n state_t get_q(std::enable_if_t k) const\n {\n return dt_ * cltv_pb_.get_q(indexToTime(k));\n }\n\n R_t get_R(std::size_t k) const\n {\n return dt_ * cltv_pb_.get_R(indexToTime(k));\n }\n\n template\n input_t get_r(std::enable_if_t k) const\n {\n return dt_ * cltv_pb_.get_r(indexToTime(k));\n }\n\n Q_t get_QT() const\n {\n double T;\n cltv_pb_.get_T(T);\n return cltv_pb_.get_QT();\n }\n\n template\n state_t get_qT([[maybe_unused]] std::enable_if_t k = nullptr) const\n {\n double TT;\n cltv_pb_.get_T(TT);\n return cltv_pb_.get_qT();\n }\n\n\n cltv_pb_t & problem()\n {\n return cltv_pb_;\n }\n\n double indexToTime(std::size_t k) const\n {\n return static_cast(k) * dt_;\n }\n\nprotected:\n double compute_dt()\n {\n double T;\n cltv_pb_.get_T(T);\n return T / static_cast(nPts - 1);\n }\n\nprotected:\n cltv_pb_t cltv_pb_{};\n double dt_{};\n};\n\n// Class template argument deduction guides\ntemplate\nDltvOcp(T)->DltvOcp;\n\ntemplate\nDltvOcp(T1, T2)->DltvOcp;\n\n} // namespace cbr\n\n\n#endif // CBR_CONTROL__MPC__DLTV_OCP_HPP_\n", "meta": {"hexsha": "b36bf0b0302f8f862f062a9927cf467ce40f091f", "size": 10503, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/cbr_control/mpc/dltv_ocp.hpp", "max_stars_repo_name": "yamaha-bps/cbr_control", "max_stars_repo_head_hexsha": "c2faf79673d46c950dd7590f1072fc7decafad06", "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/cbr_control/mpc/dltv_ocp.hpp", "max_issues_repo_name": "yamaha-bps/cbr_control", "max_issues_repo_head_hexsha": "c2faf79673d46c950dd7590f1072fc7decafad06", "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/cbr_control/mpc/dltv_ocp.hpp", "max_forks_repo_name": "yamaha-bps/cbr_control", "max_forks_repo_head_hexsha": "c2faf79673d46c950dd7590f1072fc7decafad06", "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": 31.5405405405, "max_line_length": 100, "alphanum_fraction": 0.6406740931, "num_tokens": 3113, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835411997897, "lm_q2_score": 0.5964331462646254, "lm_q1q2_score": 0.4983100771301014}} {"text": "\n// Copyright Gavin Band 2008 - 2012.\n// Distributed under the Boost Software License, Version 1.0.\n// (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include \n#include \n#include \n#include \n#include \"config/config.hpp\"\n#if HAVE_CBLAS\n\t#include \"cblas.h\"\n#endif\n#include \"Eigen/Core\"\n#include \"Eigen/Eigenvalues\"\n#include \"genfile/VariantIdentifyingData.hpp\"\n#include \"genfile/VariantDataReader.hpp\"\n#include \"genfile/vcf/get_set_eigen.hpp\"\n#include \"appcontext/get_current_time_as_string.hpp\"\n#include \"components/RelatednessComponent/PCALoadingComputer.hpp\"\n#include \"components/RelatednessComponent/LapackEigenDecomposition.hpp\"\n#include \"components/RelatednessComponent/mean_centre_genotypes.hpp\"\n\n// #define DEBUG_PCA_LOADING_COMPUTER 1\n\nnamespace {\n\ttemplate< typename Vector1, typename Vector2, typename NonMissingVector >\n\tdouble compute_correlation( Vector1 const& v1, Vector2 const& v2, NonMissingVector const& non_missingness_indicator ) {\n\t\tassert( v1.size() == v2.size() ) ;\n\t\tdouble non_missingness = non_missingness_indicator.sum() ;\n\t\tdouble mean1 = 0.0 ;\n\t\tdouble mean2 = 0.0 ;\n\t\tfor( int i = 0; i < v1.size(); ++i ) {\n\t\t\tif( non_missingness_indicator( i )) {\n\t\t\t\tmean1 += v1(i) / non_missingness ;\n\t\t\t\tmean2 += v2(i) / non_missingness ;\n\t\t\t}\n\t\t}\n\n\t\tdouble covariance = 0.0 ;\n\t\tdouble variance1 = 0.0 ;\n\t\tdouble variance2 = 0.0 ;\n\t\tfor( int i = 0; i < v1.size(); ++i ) {\n\t\t\tif( non_missingness_indicator( i )) {\n\t\t\t\tcovariance += ( v1(i) - mean1 ) * ( v2(i) - mean2 ) ;\n\t\t\t\tvariance1 += ( v1(i) - mean1 ) * ( v1(i) - mean1 ) ;\n\t\t\t\tvariance2 += ( v2(i) - mean2 ) * ( v2(i) - mean2 ) ;\n\t\t\t}\n\t\t}\n\t\t\n\t\t// We should divide the covariance by N-1 and also\n\t\t// divide each variance by the same quantity.\n\t\t// But this washes out in the ratio.\n\t\t\n\t\treturn covariance / std::sqrt( variance1 * variance2 ) ;\n\t}\n\t\n\tstd::string eigenvector_column_names( std::size_t N, std::string const& string1, std::string const& string2, std::size_t i ) {\n\t\tif( i < N ) {\n\t\t\treturn string1 + genfile::string_utils::to_string( i+1 ) ;\n\t\t}\n\t\telse {\n\t\t\treturn string2 + genfile::string_utils::to_string( i+1 -N ) ;\n\t\t}\n\t}\n}\n\nPCALoadingComputer::PCALoadingComputer( int number_of_loadings ):\n\tm_number_of_loadings( number_of_loadings ),\n\tm_number_of_snps( 1 )\n{}\n\nvoid PCALoadingComputer::set_UDUT( std::size_t number_of_snps, Matrix const& udut ) {\n\tassert( udut.cols() == udut.rows() + 1 ) ;\n\tint n = std::min( int( m_number_of_loadings ), int( udut.rows() ) ) ;\n\tm_D = udut.block( 0, 0, n, 1 ) ;\n\tm_sqrt_D_inverse = 1 / m_D.array().sqrt() ;\n\tm_U = udut.block( 0, 1, udut.rows(), n ) ;\n\tm_number_of_snps = number_of_snps ;\n}\n\nvoid PCALoadingComputer::begin_processing_snps( std::size_t number_of_samples, genfile::SNPDataSource::Metadata const& ) {\n\tassert( number_of_samples = std::size_t( m_U.rows() )) ;\n\tm_genotype_calls.resize( number_of_samples ) ;\n\tm_non_missingness.resize( number_of_samples ) ;\n}\n\nvoid PCALoadingComputer::processed_snp( genfile::VariantIdentifyingData const& snp, genfile::VariantDataReader& data_reader ) {\n\tdata_reader.get(\n\t\t\":genotypes:\",\n\t\tgenfile::vcf::get_threshholded_calls( m_genotype_calls, m_non_missingness, 0.9, 0, 0, 1, 2 )\n\t) ;\n\tassert( m_genotype_calls.size() == m_U.rows() ) ;\n\tassert( m_non_missingness.size() == m_U.rows() ) ;\n\t// setup the storage\n\tm_loading_vectors.resize( 2 * m_D.rows() ) ;\n\tm_loading_vectors.setConstant( std::numeric_limits< double >::quiet_NaN() ) ;\n\tdouble const allele_frequency = m_genotype_calls.sum() / ( 2.0 * m_non_missingness.sum() ) ;\n\tif( m_non_missingness.sum() > 0 && allele_frequency > 0.001 ) {\n\t\t//std::cerr << \"pre-mean genotypes are: \" << m_genotype_calls.head( 20 ).transpose() << \"...\\n\" ;\n\t\tpca::mean_centre_genotypes( &m_genotype_calls, m_non_missingness, allele_frequency ) ;\n\t\tm_genotype_calls /= std::sqrt( 2.0 * allele_frequency * ( 1.0 - allele_frequency ) ) ;\n\n#if DEBUG_PCA_LOADING_COMPUTER\n\t\t//std::cerr << \" SNP: \" << snp << \", allele frequency = \" << allele_frequency << \".\\n\" ;\n\t\t//std::cerr << std::resetiosflags( std::ios::floatfield ) << std::setprecision( 5 ) ;\n\t\t//std::cerr << \"pre-scale genotypes are: \" << m_genotype_calls.head( 20 ).transpose() << \"...\\n\" ;\n\t\tstd::cerr << \" genotypes are: \" << m_genotype_calls.head( 20 ).transpose() << \"...\\n\" ;\n\t\tstd::cerr << \" non-missingness is: \" << m_non_missingness.head( 20 ).transpose() << \"...\\n\" ;\n\t\tstd::cerr << \" U is: \" << m_U.block(0,0,10,10) << \"...\\n\" ;\n\t\tstd::cerr << \" D is: \" << m_D << \"...\\n\" ;\n#endif // DEBUG_PCA_LOADING_COMPUTER\n\t\n\n\t\t//\n\t\t// Let X be the L\\times n matrix (L SNPs, n samples) of (mean-centred, scaled) genotypes. We want\n\t\t// to compute the row of the matrix S of unit eigenvectors of the variance-covariance matrix\n\t\t// (1/L) X X^t that corresponds to the current SNP.\n\t\t// The matrix S is given by\n\t\t// \n\t\t// S = (1/√L) X U D^{-½}\n\t\t//\n\t\t// where\n\t\t// (1/L) X^t X = U D U^t\n\t\t// is the eigenvalue decomposition of (1/L) X^t X that we are passed in via set_UDUT (and L is the number of SNPs).\n\t\t//\n\t\t// This is true since then\n\t\t//\n\t\t// S^t S = D^{-½} U^t (1/L) X^t X U D^{-½} = id\n\t\t//\n\t\t// (so columns of S are orthogonal) while\n\t\t//\n\t\t// (1/L X X^t) S = (1/L√L) X X^t X U D^{-½}\n\t\t// = (1/√L) X U D U^t U D^{-½}\n\t\t// = (1/√L) X U D^½\n\t\t// = SD\n\t\t//\n\t\t// (so columns of S are eigenvectors with eigenvalues given by D.)\n\t\t//\n#if 0\n\t\tm_loading_vectors.segment( 0, m_U.cols() ) =\n\t\t\t( m_genotype_calls.transpose() * m_U ) * m_D.array().sqrt().matrix().asDiagonal()\n\t\t\t/ ( ( m_D.transpose().array() * m_number_of_snps ).sqrt() ) ;\n#else\n\t\tm_loading_vectors.segment( 0, m_U.cols() ) =\n\t\t\t( m_genotype_calls.transpose() * m_U ) * m_sqrt_D_inverse.asDiagonal() ;\n\t\tm_loading_vectors /= std::sqrt( m_number_of_snps ) ;\n#endif\n\t\t// We also wish to compute the correlation between the SNP and the PCA component.\n\t\t// With S as above, the PCA components are the projections of columns of X onto columns of S.\n\t\t// If we want samples to correspond to columns, this is\n\t\t// S^t X \n\t\t// which can be re-written\n\t\t// sqrt(L) U D^{1/2}\n\t\t// i.e. we may as well compute the correlation with columns of U.\n\t\tif( m_non_missingness.sum() > 10 ) {\n\t\t\tfor( int i = 0; i < m_U.cols(); ++i ) {\n\t\t\t\tm_loading_vectors( m_U.cols() + i ) = compute_correlation( m_genotype_calls, m_U.col( i ), m_non_missingness ) ;\n\t\t\t}\n\t\t}\n\t}\n\tsend_results(\n\t\tsnp,\n\t\tm_non_missingness.sum(),\n\t\tallele_frequency,\n\t\tm_loading_vectors,\n\t\tboost::bind(\n\t\t\t&eigenvector_column_names,\n\t\t\tm_U.cols(),\n\t\t\t\"eigenvector_\",\n\t\t\t\"correlation_\",\n\t\t\t_1\n\t\t)\n\t) ;\n}\n\nvoid PCALoadingComputer::send_results_to( ResultCallback callback ) {\n\tm_result_signal.connect( callback ) ;\n}\n\nvoid PCALoadingComputer::send_results( genfile::VariantIdentifyingData const& snp, double const N, double const frequency, Eigen::VectorXd const& data, GetNames get_names ) {\n\tm_result_signal( snp, N, frequency, data, get_names ) ;\n}\n\nstd::string PCALoadingComputer::get_metadata() const {\n\tusing namespace genfile::string_utils ;\n\treturn \"Number of SNPs: \" + to_string( m_number_of_snps ) + \"\\n\"\n\t\t+ \"Number of samples: \" + to_string( m_U.rows() ) + \"\\n\"\n\t\t+ \"These loadings represent unit eigenvectors of the variance-covariance matrix\\n\"\n\t\t+ \" 1/L X X^t\\n\"\n\t\t+ \"where X is the LxN matrix of genotypes at L SNPs and N samples (normalised across rows.)\" ;\n}\n\nvoid PCALoadingComputer::end_processing_snps() {}\n\n\n\n", "meta": {"hexsha": "7e78325e751419e7810949cd485fea5e68ead6ba", "size": 7582, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "components/RelatednessComponent/src/PCALoadingComputer.cpp", "max_stars_repo_name": "CreRecombinase/qctool", "max_stars_repo_head_hexsha": "6dad3a15c461177bf6940ba7b991337402ca5c41", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2021-04-21T05:42:24.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-26T14:59:43.000Z", "max_issues_repo_path": "components/RelatednessComponent/src/PCALoadingComputer.cpp", "max_issues_repo_name": "CreRecombinase/qctool", "max_issues_repo_head_hexsha": "6dad3a15c461177bf6940ba7b991337402ca5c41", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2020-04-09T16:11:04.000Z", "max_issues_repo_issues_event_max_datetime": "2020-11-10T11:18:56.000Z", "max_forks_repo_path": "components/RelatednessComponent/src/PCALoadingComputer.cpp", "max_forks_repo_name": "gavinband/qctool", "max_forks_repo_head_hexsha": "8d8adb45151c91f953fe4a9af00498073b1132ba", "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": 38.1005025126, "max_line_length": 174, "alphanum_fraction": 0.6582695859, "num_tokens": 2384, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835289107307, "lm_q2_score": 0.5964331462646255, "lm_q1q2_score": 0.49831006980049936}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"H5Cpp.h\"\n#include \"rapidjson/document.h\"\n#include \"rapidjson/writer.h\"\n#include \"rapidjson/stringbuffer.h\"\n \nusing std::cout;\nusing std::endl;\n\nusing namespace H5;\nusing namespace rapidjson;\nusing Eigen::tanh;\nusing Eigen::MatrixXd;\n\ninline double min(double a, double b) { return(((a)<(b))?(a):(b));}\ninline double max(double a, double b) { return(((a)>(b))?(a):(b));}\n\ndouble hard_sigmoid(double x){\n return(max(0.0, min(1.0, x*0.2+0.5)));\n}\n\ndouble sigmoid(double x){\n return 1.0 / (1.0 + exp(-x));\n}\n\ninline MatrixXd Mult(MatrixXd input1, MatrixXd input2){\n return(input1.array() * input2.array());\n}\n\nchar* read_model(const char *filename)\n{\n char *arch_json;\n \n H5File file(filename, H5F_ACC_RDWR);\n Attribute attr(file.openAttribute(\"model_config\"));\n DataType type(attr.getDataType());\n \n \n attr.read(type, &arch_json);\n return arch_json;\n}\n\n\ninline MatrixXd readCSV(const char* filename, int row_n, int col_n){\n \n std::ifstream file(filename);\n int col_flag = 0;\n\n MatrixXd m(row_n, col_n);\n \n\n if(row_n == 1){\n col_flag = 1;\n m.resize(col_n, row_n);\n }\n\n \n std::string line;\n \n int row = 0;\n int col = 0;\n \n \n if(file.is_open()){\n while(std::getline(file, line)){\n char *ptr = (char *)line.c_str();\n int len = line.length();\n \n col = 0;\n \n char *start = ptr;\n for(int i = 0; i < len; i++){\n if(ptr[i] == ','){\n m(row, col++) = atof(start);\n start = ptr + i + 1;\n }\n }\n m(row, col) = atof(start);\n \n row++;\n }\n file.close(); \n }\n \n if(col_flag)\n return(m.transpose());\n\n return(m);\n}\n\nclass Embedding{\n public:\n int row;\n int col;\n int out_size;\n MatrixXd W;\n\n Embedding(){\n\n }\n\n Embedding(const char* filename, int row, int col){\n this->row = row;\n this->col = col;\n this->out_size = col;\n\n W.resize(this->row, this->col);\n this->W = readCSV(filename, this->row, this->col);\n \n }\n\n MatrixXd operator()(MatrixXd input){\n MatrixXd Out(input.cols(), this->out_size);\n for(int t=0; t < Out.rows(); t++)\n Out.row(t) = W.row( input(0, t) );\n\n return(Out);\n }\n};\n\nclass LSTM{\n public:\n int inp_size;\n int out_size;\n MatrixXd kernel;\n MatrixXd recurrent_kernel;\n MatrixXd bias;\n\n LSTM(){\n\n }\n\n LSTM(const char* kernel_filename, const char* recurrent_kernel_filename, const char* bias_filename, int inp_size, int out_size){\n this->inp_size = inp_size;\n this->out_size = out_size;\n\n kernel.resize(this->inp_size, this->out_size * 4);\n kernel = readCSV(kernel_filename, this->inp_size, this->out_size * 4);\n\n recurrent_kernel.resize(this->out_size, this->out_size * 4);\n recurrent_kernel = readCSV(recurrent_kernel_filename, this->out_size, this->out_size * 4); \n \n bias.resize(1, this->out_size * 4);\n bias = readCSV(bias_filename, 1, this->out_size * 4); \n\n }\n\n MatrixXd operator()(MatrixXd input){\n int LSTM_OUT = this->out_size;\n int MAXLEN = input.rows();\n\n MatrixXd C_t = MatrixXd::Zero(1, this->out_size);\n MatrixXd h_t = MatrixXd::Zero(1, this->out_size);\n \n for(int t = 0; t < MAXLEN; t++){\n MatrixXd tmp_out(1, 4*LSTM_OUT);\n MatrixXd i_t(1, LSTM_OUT);\n MatrixXd f_t(1, LSTM_OUT);\n MatrixXd o_t(1, LSTM_OUT);\n MatrixXd g_t(1, LSTM_OUT);\n \n // IFCO\n tmp_out = input.row(t) * kernel + h_t * recurrent_kernel + bias;\n \n i_t = (tmp_out.block(0, 0*LSTM_OUT, 1, LSTM_OUT)).unaryExpr(&hard_sigmoid);\n f_t = (tmp_out.block(0, 1*LSTM_OUT, 1, LSTM_OUT)).unaryExpr(&hard_sigmoid);\n o_t = (tmp_out.block(0, 3*LSTM_OUT, 1, LSTM_OUT)).unaryExpr(&hard_sigmoid);\n g_t = tanh((tmp_out.block(0, 2*LSTM_OUT, 1, LSTM_OUT)).array());\n \n C_t = f_t.array() * C_t.array() + i_t.array() * g_t.array();\n h_t = o_t.array() * tanh(C_t.array());\n }\n return h_t; \n } \n};\n\nclass GRU{\n public:\n int inp_size;\n int out_size;\n MatrixXd kernel;\n MatrixXd recurrent_kernel;\n MatrixXd bias;\n\n GRU(){\n\n }\n\n GRU(const char* kernel_filename, const char* recurrent_kernel_filename, const char* bias_filename, int inp_size, int out_size){\n this->inp_size = inp_size;\n this->out_size = out_size;\n\n kernel.resize(this->inp_size, this->out_size * 4);\n kernel = readCSV(kernel_filename, this->inp_size, this->out_size * 4);\n\n recurrent_kernel.resize(this->out_size, this->out_size * 4);\n recurrent_kernel = readCSV(recurrent_kernel_filename, this->out_size, this->out_size * 4); \n \n bias.resize(1, this->out_size * 4);\n bias = readCSV(bias_filename, 1, this->out_size * 4); \n\n }\n\n MatrixXd operator()(MatrixXd input){\n int LSTM_OUT = this->out_size;\n int MAXLEN = input.rows();\n\n MatrixXd hh_t = MatrixXd::Zero(1,LSTM_OUT);\n MatrixXd h_t = MatrixXd::Zero(1,LSTM_OUT);\n MatrixXd one_arr = MatrixXd::Ones(1,LSTM_OUT);\n \n MatrixXd tmp_out(1, 3*LSTM_OUT);\n MatrixXd tmp_W(1, LSTM_OUT);\n MatrixXd tmp_U(LSTM_OUT, LSTM_OUT);\n MatrixXd z_t(1, LSTM_OUT);\n MatrixXd r_t(1, LSTM_OUT);\n \n tmp_U = recurrent_kernel.block(0, 2*LSTM_OUT, LSTM_OUT, LSTM_OUT);\n \n for(int t = 0; t < MAXLEN; t++){\n \n // IFCO\n \n tmp_W = input.row(t) * kernel + bias ;\n tmp_out = tmp_W + h_t * recurrent_kernel;\n \n z_t = (tmp_out.block(0, 0*LSTM_OUT, 1, LSTM_OUT)).unaryExpr(&hard_sigmoid);\n r_t = (tmp_out.block(0, 1*LSTM_OUT, 1, LSTM_OUT)).unaryExpr(&hard_sigmoid);\n r_t = r_t.array() * h_t.array();\n \n hh_t = tanh((r_t * tmp_U + tmp_W.block(0, 2*LSTM_OUT, 1, LSTM_OUT)).array() );\n h_t = (one_arr - z_t).array() * hh_t.array() + z_t.array() * h_t.array(); \n \n }\n return h_t;\n } \n};\n\nclass Dense{\n public:\n int inp_size;\n int out_size;\n string activation;\n MatrixXd kernel;\n MatrixXd bias;\n\n Dense(){\n\n }\n\n Dense(const char* kernel_filename, const char* bias_filename, int inp_size, int out_size, string activation=\"linear\"){\n this->inp_size = inp_size;\n this->out_size = out_size;\n this->activation = activation;\n\n kernel.resize(this->inp_size, this->out_size);\n kernel = readCSV(kernel_filename, this->inp_size, this->out_size);\n\n bias.resize(1, this->out_size);\n bias = readCSV(bias_filename, 1, this->out_size);\n }\n\n MatrixXd operator()(MatrixXd input){\n\n if(this->activation == \"linear\")\n return( input * kernel + bias );\n else if(this->activation == \"sigmoid\")\n return( (input * kernel + bias).unaryExpr(&sigmoid) );\n }\n};\n", "meta": {"hexsha": "c45dce25572baf1d23d0cf5968cf779a781f4b87", "size": 7965, "ext": "cc", "lang": "C++", "max_stars_repo_path": "cc/module.cc", "max_stars_repo_name": "VishnuDuttSharma/KeLiPTo", "max_stars_repo_head_hexsha": "c5730fcb25dec199ce41b12e08ee442a00aa6c43", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-09-12T21:59:19.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-04T09:26:22.000Z", "max_issues_repo_path": "cc/module.cc", "max_issues_repo_name": "VishnuDuttSharma/KeLiPTo", "max_issues_repo_head_hexsha": "c5730fcb25dec199ce41b12e08ee442a00aa6c43", "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": "cc/module.cc", "max_forks_repo_name": "VishnuDuttSharma/KeLiPTo", "max_forks_repo_head_hexsha": "c5730fcb25dec199ce41b12e08ee442a00aa6c43", "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.5483870968, "max_line_length": 136, "alphanum_fraction": 0.521908349, "num_tokens": 1979, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835289107309, "lm_q2_score": 0.5964331462646254, "lm_q1q2_score": 0.4983100698004993}} {"text": "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"spectral/hermiten.hpp\"\n#include \"spectral/mpfr/import_std_math.hpp\"\n\nnamespace boltzmann {\n\n// ----------------------------------------------------------------------\nnamespace detail {\ntemplate \nclass sentry\n{\n public:\n typedef NUMERIC_T numeric_t;\n\n private:\n typedef std::vector vec_t;\n\n public:\n sentry(int n) { this->init(n); }\n\n sentry() { /* empty */}\n\n void init(int n)\n {\n n_ = n;\n factors_.resize(6);\n std::for_each(factors_.begin(), factors_.end(), [&](vec_t& v) { v.reserve(n + 1); });\n }\n\n NUMERIC_T coeff(int i, int j, int t);\n NUMERIC_T operator()(int i, int j, numeric_t x);\n\n private:\n int n_;\n std::vector factors_;\n};\n\n// ----------------------------------------------------------------------\ntemplate \nNUMERIC_T\nsentry::coeff(int i, int j, int t)\n{\n const int maxij = std::max(i, j);\n const int minij = std::min(i, j);\n // (min(i,j) ... 1)\n auto& v0 = factors_[0];\n v0.resize(minij);\n for (int k = 0; k < minij; ++k) {\n v0[k] = std::min(i, j) - k;\n }\n\n // sqrt(max(i,j) .. min(i,j)+1)\n auto& v1 = factors_[1];\n v1.resize(maxij - minij);\n for (int k = 0; k < maxij - minij; ++k) {\n v1[k] = ::math::sqrt(numeric_t(maxij - k));\n }\n\n // (i-t)!\n auto& v2 = factors_[2];\n v2.resize(i - t);\n for (int k = 0; k < i - t; ++k) {\n v2[k] = 1 / numeric_t(i - t - k);\n }\n\n // (j-t)!\n auto& v3 = factors_[3];\n v3.resize(j - t);\n for (int k = 0; k < j - t; ++k) {\n v3[k] = 1 / numeric_t(j - t - k);\n }\n\n // t!\n auto& v4 = factors_[4];\n v4.resize(t);\n for (int k = 0; k < t; ++k) {\n v4[k] = 1 / numeric_t(t - k);\n }\n\n // 2^(t-(i+j)/2)\n auto& v5 = factors_[5];\n int exp2 = t - (i + j) / 2;\n v5.resize(std::abs(exp2));\n if (exp2 > 0)\n for (unsigned int k = 0; k < v5.size(); ++k) {\n v5[k] = 2;\n }\n else\n for (unsigned int k = 0; k < v5.size(); ++k) {\n v5[k] = 1 / numeric_t(2);\n }\n // cout << \"v5:\\t\";\n // for_each(v5.begin(), v5.end(), [](numeric_t v) { cout << v << \"\\t\"; });\n // cout << endl;\n\n std::sort(factors_.begin(), factors_.end(), [](const vec_t& v1, const vec_t& v2) {\n return v1.size() < v2.size();\n });\n std::vector lengths;\n std::for_each(\n factors_.begin(), factors_.end(), [&](const vec_t& v) { lengths.push_back(v.size()); });\n\n numeric_t f = (std::abs(i - t) % 2) ? -1 : 1;\n // multiply\n for (int jp = 0; jp < lengths[0]; ++jp) {\n numeric_t loc = 1;\n for (unsigned int fi = 0; fi < factors_.size(); ++fi) {\n loc *= factors_[fi][jp];\n }\n f *= loc;\n }\n for (unsigned int l = 1; l < lengths.size(); ++l) {\n for (int jp = lengths[l - 1]; jp < lengths[l]; ++jp) { // loop over remaining positions\n numeric_t loc = 1;\n for (unsigned int fi = l; fi < factors_.size(); ++fi) {\n loc *= factors_[fi][jp];\n }\n f *= loc;\n }\n }\n\n // 2^(t-(i+j)/2) missing term\n if ((i + j) % 2 && exp2 <= 0)\n f /= ::math::sqrt(numeric_t(2));\n else if ((i + j) % 2 && exp2 > 0)\n f *= ::math::sqrt(numeric_t(2));\n\n return f;\n}\n\n// ----------------------------------------------------------------------\ntemplate \nNUMERIC_T\nsentry::operator()(int i, int j, numeric_t x)\n{\n numeric_t sum = 0;\n\n // TOOD implement Horner's scheme\n for (int l = std::abs(i - j); l <= i + j; l += 2) {\n numeric_t loc = this->coeff(i, j, (i + j - l) / 2);\n\n sum += loc * ::math::pow(x, l);\n }\n\n return sum * ::math::exp(numeric_t(-x * x / 4));\n ;\n}\n\n/**\n * @brief polyval (Horner scheme)\n *\n * @param coeffs\n * @param x\n * @param N length of coeffs\n */\ntemplate \ninline NUMERIC_T\npolyval(NUMERIC_T* coeffs, NUMERIC_T x, int N)\n{\n typedef NUMERIC_T numeric_t;\n numeric_t b = coeffs[N - 1];\n for (int i = 1; i < N - 1; ++i) {\n b = coeffs[N - 1 - i] + b * x;\n }\n return x * b + coeffs[0];\n}\n\n} // end namespace detail\n\n// ----------------------------------------------------------------------\n/**\n * @brief Assemble shift matrix \\f$ S^{\\bar{x}}\\f$.\n *\n * @tparam NUMERIC_T numeric type\n *\n */\ntemplate \nclass HShiftMatrix\n{\n private:\n typedef NUMERIC_T numeric_t;\n typedef std::vector vec_t;\n\n public:\n typedef Eigen::Matrix matrix_t;\n\n public:\n /**\n *\n * @param N max polynomial degree\n */\n HShiftMatrix(int N) { this->init(N); }\n\n HShiftMatrix() { /* empty */}\n\n /**\n * Compute polynomial coefficients of p(i,j;x)\n *\n */\n void init(int N);\n\n /**\n * Create linear Operator S^x by evaluating the polynomial\n *\n * @param x\n */\n void setx(numeric_t x);\n\n const matrix_t& get() const { return S_; }\n void dump(std::string fname) const;\n\n private:\n int size_;\n boost::multi_array coeffs_;\n /* compute coefficients of the S_-entry polynomial */\n detail::sentry G_;\n matrix_t S_;\n};\n\n// ----------------------------------------------------------------------\ntemplate \nvoid\nHShiftMatrix::init(int N)\n{\n size_ = N + 1;\n G_.init(N + 1);\n S_.resize(N + 1, N + 1);\n coeffs_.resize(boost::extents[size_][size_][2 * size_ - 1]);\n\n // std::fill(coeffs_.origin(), coeffs_.origin() + coeffs_.num_elements(), 0);\n for (int i = 0; i < size_; ++i) {\n for (int j = 0; j < size_; ++j) {\n for (int l = std::abs(i - j); l <= i + j; l += 2) {\n coeffs_[i][j][l] = G_.coeff(i, j, (i + j - l) / numeric_t(2));\n }\n }\n }\n}\n\n// ----------------------------------------------------------------------\ntemplate \nvoid\nHShiftMatrix::setx(numeric_t x)\n{\n // Hint: polyval can be further optimized by using knowledge\n // about which coefficients are zero.\n numeric_t f = ::math::exp(numeric_t(-x * x / 4));\n for (int i = 0; i < size_; ++i) {\n for (int j = 0; j < size_; ++j) {\n S_(i, j) = f * detail::polyval(coeffs_[i][j].origin(), x, coeffs_.shape()[2]);\n }\n }\n}\n\n// ----------------------------------------------------------------------\ntemplate \nvoid\nHShiftMatrix::dump(std::string fname) const\n{\n std::ofstream fout(fname);\n fout << std::setprecision(10);\n fout << std::scientific;\n fout << S_;\n fout.close();\n}\n\n} // end namespace boltzmann\n", "meta": {"hexsha": "0834262d0fd16b032f75b7a3bc6efd883292e3f3", "size": 6530, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "spectral/shift_hermite.hpp", "max_stars_repo_name": "simonpp/2dRidgeletBTE", "max_stars_repo_head_hexsha": "5d08cbb5c57fc276c7a528f128615d23c37ef6a0", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-11-08T03:15:56.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-08T03:15:56.000Z", "max_issues_repo_path": "spectral/shift_hermite.hpp", "max_issues_repo_name": "simonpp/2dRidgeletBTE", "max_issues_repo_head_hexsha": "5d08cbb5c57fc276c7a528f128615d23c37ef6a0", "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": "spectral/shift_hermite.hpp", "max_forks_repo_name": "simonpp/2dRidgeletBTE", "max_forks_repo_head_hexsha": "5d08cbb5c57fc276c7a528f128615d23c37ef6a0", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-11-08T03:15:56.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-08T03:15:56.000Z", "avg_line_length": 23.4892086331, "max_line_length": 94, "alphanum_fraction": 0.5234303216, "num_tokens": 2077, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802476562641, "lm_q2_score": 0.6477982247516797, "lm_q1q2_score": 0.4982088191233101}} {"text": "//==================================================================================================\n/*!\n @file\n\n @copyright 2016 NumScale SAS\n @copyright 2016 J.T. Lapreste\n\n Distributed under the Boost Software License, Version 1.0.\n (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)\n*/\n//==================================================================================================\n#ifndef BOOST_SIMD_FUNCTION_DIVS_HPP_INCLUDED\n#define BOOST_SIMD_FUNCTION_DIVS_HPP_INCLUDED\n\n#if defined(DOXYGEN_ONLY)\nnamespace boost { namespace simd\n{\n\n /*!\n\n @ingroup group-arithmetic\n Function object implementing divs capabilities\n\n Computes the truncated saturated division of its parameters.\n\n @par semantic:\n For any given value @c x, @c y of type @c T:\n\n @code\n T r = divs(x, y);\n @endcode\n\n The code is similar to:\n\n @code\n T r = trunc(x/y);\n @endcode\n\n for integral types, if y is @ref Zero, it returns @ref Valmax (resp. @ref Valmin)\n if x is positive (resp. negative) and @ref Zero if x is @ref Zero.\n\n Saturated means that for signed integer types,\n @c divs(Valmin,-1) returns @ref Valmax.\n\n @par Alias\n\n @c rdivide\n\n @see divides, rec, divfloor, divceil, divround, divround2even, divfix\n\n **/\n const boost::dispatch::functor divs = {};\n} }\n#endif\n\n#include \n#include \n\n#endif\n", "meta": {"hexsha": "b96809f4511f2237bd289c6e046d0bc20ce8cc14", "size": 1461, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/boost/simd/function/divs.hpp", "max_stars_repo_name": "yaeldarmon/boost.simd", "max_stars_repo_head_hexsha": "561316cc54bdc6353ca78f3b6d7e9120acd11144", "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/boost/simd/function/divs.hpp", "max_issues_repo_name": "yaeldarmon/boost.simd", "max_issues_repo_head_hexsha": "561316cc54bdc6353ca78f3b6d7e9120acd11144", "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/boost/simd/function/divs.hpp", "max_forks_repo_name": "yaeldarmon/boost.simd", "max_forks_repo_head_hexsha": "561316cc54bdc6353ca78f3b6d7e9120acd11144", "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": 24.35, "max_line_length": 100, "alphanum_fraction": 0.5954825462, "num_tokens": 356, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802476562641, "lm_q2_score": 0.647798211152541, "lm_q1q2_score": 0.49820880866448114}} {"text": "#include \"Common.h\"\n#include \"CPS3.h\"\n#include \"PropertiesHolder/PropertiesHolder.h\"\n#include \"Material.h\"\n#include \n\nvoid CPS3::SetIndices(const std::vector& indices)\n{\n\tassert(indices.size() == 3);\n\tm_nodes[0] = indices[0];\n\tm_nodes[1] = indices[1];\n\tm_nodes[2] = indices[2];\n}\n\nstd::vector CPS3::GetIndices() const\n{\n\tstd::vector indices(3);\n\tindices[0] = m_nodes[0];\n\tindices[1] = m_nodes[1];\n\tindices[2] = m_nodes[2];\n\treturn indices;\n}\n\nstd::vector CPS3::GetFunctionValuesAtNodes(const Eigen::VectorXf& deforms)const\n{\n\tEigen::Matrix uv;\n\tfor (int i = 0; i < 3; ++i)\n\t{\n\t\tuv[2 * i + 0] = deforms[2 * m_nodes[i] + 0];\n\t\tuv[2 * i + 1] = deforms[2 * m_nodes[i] + 1];\n\t}\n\n\tEigen::Vector3f strain = m_B * uv;\n\t\n\tstd::vector output;\n\tfor (int i = 0; i < 3; i++)\n\t{\n\t\toutput.push_back(strain);\n\t}\n\treturn output;\n}\n\nvoid CPS3::CalcK(const StrideDataArray& nodes, const tfem::MaterialPtr mat, std::vector >& tripletVector)\n{\n\tm_mat = mat;\n\tEigen::Vector3f x;\n\tEigen::Vector3f y;\n\tfor (int i = 0; i < 3; ++i)\n\t{\n\t\tx[i] = nodes(m_nodes[i], 0);\n\t\ty[i] = nodes(m_nodes[i], 1);\n\t}\n\tEigen::Matrix3f C;\n\tC << Eigen::Vector3f(1.0f, 1.0f, 1.0f), x, y;\n\n\tfloat area = C.determinant() / 2.0f;\n\n\tEigen::Matrix3f IC = C.inverse();\n\t\n\tfor (int i = 0; i < 3; i++)\n\t{\n\t\tm_B(0, 2 * i + 0) = IC(1, i);\n\t\tm_B(0, 2 * i + 1) = 0.0f;\n\t\tm_B(1, 2 * i + 0) = 0.0f;\n\t\tm_B(1, 2 * i + 1) = IC(2, i);\n\t\tm_B(2, 2 * i + 0) = IC(2, i);\n\t\tm_B(2, 2 * i + 1) = IC(1, i);\n\t}\n\tEigen::Matrix K = m_B.transpose() * mat->GetElasticityMatrix(fem::PT_FlatStress) * m_B * area;\n\tGrabTriplets(K, tripletVector);\n}\n\nvoid CPS3::GrabTriplets(const Eigen::Matrix& K, std::vector >& tripletVector) const\n{\n\tfor (int i = 0; i < 3; i++)\n\t{\n\t\tfor (int j = 0; j < 3; j++)\n\t\t{\n\t\t\tEigen::Triplet trplt11(2 * m_nodes[i] + 0, 2 * m_nodes[j] + 0, K(2 * i + 0, 2 * j + 0));\n\t\t\tEigen::Triplet trplt12(2 * m_nodes[i] + 0, 2 * m_nodes[j] + 1, K(2 * i + 0, 2 * j + 1));\n\t\t\tEigen::Triplet trplt21(2 * m_nodes[i] + 1, 2 * m_nodes[j] + 0, K(2 * i + 1, 2 * j + 0));\n\t\t\tEigen::Triplet trplt22(2 * m_nodes[i] + 1, 2 * m_nodes[j] + 1, K(2 * i + 1, 2 * j + 1));\n\n\t\t\ttripletVector.push_back(trplt11);\n\t\t\ttripletVector.push_back(trplt12);\n\t\t\ttripletVector.push_back(trplt21);\n\t\t\ttripletVector.push_back(trplt22);\n\t\t}\n\t}\n}\n\ntfem::Material* CPS3::GetMaterial()\n{\n\treturn m_mat.get();\n}\n\nIElement* CPS3::Create()\n{\n\treturn new CPS3;\n}\n\nCPS3::CPS3()\n{\n\n}", "meta": {"hexsha": "9eaa6598b8d194b51e60bfb8ddb86aedf0750184", "size": 2548, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "sources/Elements/CPS3.cpp", "max_stars_repo_name": "podgorskiy/TinyFEM", "max_stars_repo_head_hexsha": "c1a5fedf21e6306fc11fa19afdaf48dab1b6740f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2017-11-05T14:01:04.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-11T15:24:54.000Z", "max_issues_repo_path": "sources/Elements/CPS3.cpp", "max_issues_repo_name": "podgorskiy/TinyFEM", "max_issues_repo_head_hexsha": "c1a5fedf21e6306fc11fa19afdaf48dab1b6740f", "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": "sources/Elements/CPS3.cpp", "max_forks_repo_name": "podgorskiy/TinyFEM", "max_forks_repo_head_hexsha": "c1a5fedf21e6306fc11fa19afdaf48dab1b6740f", "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.2666666667, "max_line_length": 127, "alphanum_fraction": 0.5973312402, "num_tokens": 1045, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424373085146, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.4981663065862324}} {"text": "#include \n#include \n#include \n#include \n\nusing namespace Utility;\nusing Utility::Constants::Pi;\n\nnamespace Engine\n{\nnamespace Solver_Kernels\n{\n\n void sib_transform(const vectorfield & spins, const vectorfield & force, vectorfield & out)\n {\n int n = spins.size();\n\n auto s = spins.data();\n auto f = force.data();\n auto o = out.data();\n\n Backend::par::apply( n, [s,f,o] SPIRIT_LAMBDA (int idx) {\n Vector3 e1, a2, A;\n scalar detAi;\n e1 = s[idx];\n A = 0.5 * f[idx];\n\n // 1/determinant(A)\n detAi = 1.0 / (1 + pow(A.norm(), 2.0));\n\n // calculate equation witho the predictor?\n a2 = e1 - e1.cross(A);\n\n o[idx][0] = (a2[0] * (A[0] * A[0] + 1 ) + a2[1] * (A[0] * A[1] - A[2]) + a2[2] * (A[0] * A[2] + A[1])) * detAi;\n o[idx][1] = (a2[0] * (A[1] * A[0] + A[2]) + a2[1] * (A[1] * A[1] + 1 ) + a2[2] * (A[1] * A[2] - A[0])) * detAi;\n o[idx][2] = (a2[0] * (A[2] * A[0] - A[1]) + a2[1] * (A[2] * A[1] + A[0]) + a2[2] * (A[2] * A[2] + 1 )) * detAi;\n } );\n }\n\n void oso_calc_gradients(vectorfield & grad, const vectorfield & spins, const vectorfield & forces)\n {\n const Matrix3 t = ( Matrix3() << 0,0,1,0,-1,0,1,0,0 ).finished();\n\n auto g=grad.data();\n auto s=spins.data();\n auto f=forces.data();\n\n Backend::par::apply( spins.size(), [g,s,f,t] SPIRIT_LAMBDA (int idx)\n {\n g[idx] = t * (-s[idx].cross(f[idx]));\n }\n );\n }\n\n void oso_rotate( std::vector> & configurations, std::vector & searchdir)\n {\n int noi = configurations.size();\n int nos = configurations[0]->size();\n for(int img=0; imgdata();\n auto sd = searchdir[img].data();\n \n Backend::par::apply( nos, [s, sd] SPIRIT_LAMBDA (int idx) \n {\n scalar theta = (sd[idx]).norm();\n scalar q = cos(theta), w = 1-q, \n x = -sd[idx][0]/theta, y = -sd[idx][1]/theta, z = -sd[idx][2]/theta,\n s1 = -y*z*w, s2 = x*z*w, s3 = -x*y*w,\n p1 = x*sin(theta), p2 = y*sin(theta), p3 = z*sin(theta);\n\n scalar t1, t2, t3;\n if(theta > 1.0e-20) // if theta is too small we do nothing\n {\n t1 = (q+z*z*w) * s[idx][0] + (s1+p1) * s[idx][1] + (s2+p2) * s[idx][2];\n t2 = (s1-p1) * s[idx][0] + (q+y*y*w) * s[idx][1] + (s3+p3) * s[idx][2];\n t3 = (s2-p2) * s[idx][0] + (s3-p3) * s[idx][1] + (q+x*x*w) * s[idx][2];\n s[idx][0] = t1;\n s[idx][1] = t2;\n s[idx][2] = t3;\n };\n }\n );\n }\n }\n\n scalar maximum_rotation(const vectorfield & searchdir, scalar maxmove)\n {\n int nos = searchdir.size();\n scalar theta_rms = 0;\n theta_rms = sqrt( Backend::par::reduce(searchdir, [] SPIRIT_LAMBDA (const Vector3 & v){ return v.squaredNorm(); }) / nos );\n scalar scaling = (theta_rms > maxmove) ? maxmove/theta_rms : 1.0;\n return scaling;\n }\n\n void atlas_rotate(std::vector> & configurations, const std::vector & a3_coords, const std::vector & searchdir)\n {\n int noi = configurations.size();\n int nos = configurations[0]->size();\n for(int img=0; imgdata();\n auto d = searchdir[img].data();\n auto a3 = a3_coords[img].data();\n Backend::par::apply(nos, [nos, spins, d, a3] SPIRIT_LAMBDA (int idx) {\n const scalar gamma = (1 + spins[idx][2] * a3[idx]);\n const scalar denom = (spins[idx].head<2>().squaredNorm())/gamma + 2 * d[idx].dot( spins[idx].head<2>() ) + gamma * d[idx].squaredNorm();\n spins[idx].head<2>() = 2*(spins[idx].head<2>() + d[idx]*gamma);\n spins[idx][2] = a3[idx] * (gamma - denom);\n spins[idx] *= 1/(gamma + denom);\n } );\n }\n }\n\n void atlas_calc_gradients(vector2field & residuals, const vectorfield & spins, const vectorfield & forces, const scalarfield & a3_coords)\n {\n auto s = spins.data();\n auto a3 = a3_coords.data();\n auto g = residuals.data();\n auto f = forces.data();\n\n Backend::par::apply(spins.size(), [s, a3, g, f] SPIRIT_LAMBDA (int idx) {\n\n scalar J00 = s[idx][1] * s[idx][1] + s[idx][2]*(s[idx][2] + a3[idx]);\n scalar J10 = -s[idx][0] * s[idx][1];\n scalar J01 = -s[idx][0] * s[idx][1];\n scalar J11 = s[idx][0] * s[idx][0] + s[idx][2]*(s[idx][2] + a3[idx]);\n scalar J02 = -s[idx][0] * (s[idx][2] + a3[idx]);\n scalar J12 = -s[idx][1] * (s[idx][2] + a3[idx]);\n\n g[idx][0] = -(J00 * f[idx][0] + J01 * f[idx][1] + J02 * f[idx][2]);\n g[idx][1] = -(J10 * f[idx][0] + J11 * f[idx][1] + J12 * f[idx][2]);\n });\n }\n\n bool ncg_atlas_check_coordinates(const std::vector> & spins, std::vector & a3_coords, scalar tol)\n {\n int noi = spins.size();\n int nos = (*spins[0]).size();\n\n // We use `int` instead of `bool`, because somehow cuda does not like pointers to bool\n // TODO: fix in future\n field result = field(1, int(false));\n\n for(int img=0; imgdata();\n auto a3 = a3_coords[img].data();\n int *res = &result[0];\n\n Backend::par::apply( nos, [s, a3, tol, res] SPIRIT_LAMBDA (int idx) {\n if (s[idx][2]*a3[idx] < tol && res[0] == int(false))\n res[0] = int(true);\n } );\n }\n\n return bool(result[0]);\n }\n\n void lbfgs_atlas_transform_direction(std::vector> & configurations, std::vector & a3_coords, std::vector> & atlas_updates, std::vector> & grad_updates, std::vector & searchdir, std::vector & grad_pr, scalarfield & rho)\n {\n int noi = configurations.size();\n int nos = configurations[0]->size();\n\n for(int n=0; n t1(n_mem), t2(n_mem);\n for(int n=0; n 0) ? 1 : -1;\n factor = (1 - a3[idx] * s[idx][2]) / (1 + a3[idx] * s[idx][2]);\n sd[idx] *= factor;\n g_pr[idx] *= factor;\n\n for(int n=0; n\n#include \n\n#include \"LHLExtractor.h\"\n\nuint32_t LHLExtractor::getInputLength() const {\n return n_;\n}\n\nuint32_t LHLExtractor::getSeedLen() const {\n return n_;\n}\n\nuint32_t LHLExtractor::getOutputLen() const {\n return m_;\n}\n\ndouble LHLExtractor::getMinEntropy() const {\n return k_;\n}\n\ndouble LHLExtractor::getError() const {\n return error_;\n}\n\nBitstring LHLExtractor::extract(const WeakSource &input, const Bitstring &seed) const {\n assert(input.getMinEntropy() >= k_);\n assert(seed.size() == n_);\n NTL::GF2EPush push;\n NTL::GF2E::init(NTL::BuildSparseIrred_GF2X(n_));\n auto x = input.getData().asGF2E();\n auto y = seed.asGF2E();\n return Bitstring((Bitstring(x) + Bitstring(y)).substr(0, m_));\n}\n\nLHLExtractor::LHLExtractor(uint32_t n, uint32_t k, double eps): n_(n), k_(k), error_(eps) {\n m_ = ceil(k_ + n_ - 2 * log2(1. / error_));\n}\n", "meta": {"hexsha": "b4f75620807db7323d5892dc614910848de6c079", "size": 914, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "extractor/seeded/LHLExtractor.cpp", "max_stars_repo_name": "Skird/extractors", "max_stars_repo_head_hexsha": "3c55d2c8377f465a4960861b7f358b18214f5ac3", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-06-11T17:19:48.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-11T17:19:48.000Z", "max_issues_repo_path": "extractor/seeded/LHLExtractor.cpp", "max_issues_repo_name": "Skird/extractors", "max_issues_repo_head_hexsha": "3c55d2c8377f465a4960861b7f358b18214f5ac3", "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": "extractor/seeded/LHLExtractor.cpp", "max_forks_repo_name": "Skird/extractors", "max_forks_repo_head_hexsha": "3c55d2c8377f465a4960861b7f358b18214f5ac3", "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": 23.4358974359, "max_line_length": 91, "alphanum_fraction": 0.6739606127, "num_tokens": 282, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424295406088, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.4981663020117971}} {"text": "#pragma once\n\n#include \"craam/RMDP.hpp\"\n\n#include \n#include \n\nnamespace craam{namespace algorithms{\n\nusing namespace std;\nusing namespace Eigen;\n\n/// Internal helper functions\nnamespace internal{\n\n /// Helper function to deal with variable indexing\n template\n inline Transition mean_transition_state(const SType& state, long index, const pair>& policies){\n return state.mean_transition(policies.first[index], policies.second[index]);\n }\n\n /// Helper function to deal with variable indexing\n template\n inline Transition mean_transition_state(const SType& state, long index, const indvec& policy){\n return state.mean_transition(policy[index]);\n }\n\n /// Helper function to deal with variable indexing\n template\n inline prec_t mean_reward_state(const SType& state, long index, const pair>& policies){\n return state.mean_reward(policies.first[index], policies.second[index]);\n }\n\n /// Helper function to deal with variable indexing\n template\n inline prec_t mean_reward_state(const SType& state, long index, const indvec& policy){\n return state.mean_reward(policy[index]);\n }\n}\n\n/**\nConstructs the transition (or its transpose) matrix for the policy.\n\n\\tparam SType Type of the state in the MDP (regular vs robust)\n\\tparam Policy Type of the policy. Either a single policy for\n the standard MDP evaluation, or a pair of a deterministic \n policy and a randomized policy of the nature\n\\param rmdp Regular or robust MDP\n\\param policies The policy (indvec) or the pair of the policy and the policy\n of nature (pair >). The nature is typically \n a randomized policy\n\\param transpose (optional, false) Whether to return the transpose of the transition matrix. \n This is useful for computing occupancy frequencies\n*/\ntemplate \ninline MatrixXd transition_mat(const GRMDP& rmdp, const Policies& policies, bool transpose = false) {\n const size_t n = rmdp.state_count();\n MatrixXd result = MatrixXd::Zero(n,n);\n\n const auto& states = rmdp.get_states();\n #pragma omp parallel for\n for(size_t s = 0; s < n; s++){\n const Transition&& t = internal::mean_transition_state(states[s], s, policies);\n\n const auto& indexes = t.get_indices();\n const auto& probabilities = t.get_probabilities();\n\n if(!transpose){\n for(size_t j=0; j < t.size(); j++)\n result(s,indexes[j]) = probabilities[j];\n }else{\n for(size_t j=0; j < t.size(); j++)\n result(indexes[j],s) = probabilities[j];\n }\n }\n return result;\n}\n\n/**\nConstructs the rewards vector for each state for the RMDP.\n\n\\tparam Policy Type of the policy. Either a single policy for\n the standard MDP evaluation, or a pair of a deterministic \n policy and a randomized policy of the nature\n\\param rmdp Regular or robust MDP\n\\param policies The policy (indvec) or the pair of the policy and the policy\n of nature (pair >). The nature is typically \n a randomized policy\n */\ntemplate\ninline numvec rewards_vec(const GRMDP& rmdp, const Policy& policies){\n \n const auto n = rmdp.state_count();\n numvec rewards(n);\n\n #pragma omp parallel for\n for(size_t s=0; s < n; s++){\n const SType& state = rmdp[s];\n if(state.is_terminal())\n rewards[s] = 0;\n else\n rewards[s] = internal::mean_reward_state(state, s, policies);\n }\n return rewards;\n}\n\n/**\nComputes occupancy frequencies using matrix representation of transition\nprobabilities. This method may not scale well\n\n\n\\tparam SType Type of the state in the MDP (regular vs robust)\n\\tparam Policy Type of the policy. Either a single policy for\n the standard MDP evaluation, or a pair of a deterministic \n policy and a randomized policy of the nature\n\\param init Initial distribution (alpha)\n\\param discount Discount factor (gamma)\n\\param policies The policy (indvec) or the pair of the policy and the policy\n of nature (pair >). The nature is typically \n a randomized policy\n*/\ntemplate\ninline numvec \noccfreq_mat(const GRMDP& rmdp, const Transition& init, prec_t discount,\n const Policies& policies) {\n const auto n = rmdp.state_count();\n\n // initial distribution\n const numvec& ivec = init.probabilities_vector(n);\n const VectorXd initial_vec = Map(ivec.data(),ivec.size());\n\n // get transition matrix and construct (I - gamma * P^T)\n MatrixXd t_mat = MatrixXd::Identity(n,n) - discount * transition_mat(rmdp, policies, true);\n\n // solve set of linear equations\n numvec result(n,0);\n Map(result.data(),result.size()) = HouseholderQR(t_mat).solve(initial_vec);\n\n return result;\n}\n\n}}\n", "meta": {"hexsha": "02b75a82706ec586d3287a70158c77cff098e73e", "size": 5149, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "craam/algorithms/occupancies.hpp", "max_stars_repo_name": "marekpetrik/CRAAM", "max_stars_repo_head_hexsha": "62cc392e876b5383faa5cb15ab1f6b70b26ff395", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 22.0, "max_stars_repo_stars_event_min_datetime": "2015-09-28T14:41:00.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-03T00:16:19.000Z", "max_issues_repo_path": "craam/algorithms/occupancies.hpp", "max_issues_repo_name": "marekpetrik/CRAAM", "max_issues_repo_head_hexsha": "62cc392e876b5383faa5cb15ab1f6b70b26ff395", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2017-08-10T18:35:40.000Z", "max_issues_repo_issues_event_max_datetime": "2018-10-13T01:38:04.000Z", "max_forks_repo_path": "craam/algorithms/occupancies.hpp", "max_forks_repo_name": "marekpetrik/CRAAM", "max_forks_repo_head_hexsha": "62cc392e876b5383faa5cb15ab1f6b70b26ff395", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2016-09-19T18:31:07.000Z", "max_forks_repo_forks_event_max_datetime": "2018-07-05T08:59:45.000Z", "avg_line_length": 36.006993007, "max_line_length": 121, "alphanum_fraction": 0.6879005632, "num_tokens": 1154, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506635289836, "lm_q2_score": 0.6548947155710233, "lm_q1q2_score": 0.49814609994072384}} {"text": "// (C) Copyright John Maddock 2006.\n// Use, modification and distribution are subject to the\n// Boost Software License, Version 1.0. (See accompanying file\n// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n\n#define BOOST_UBLAS_TYPE_CHECK_EPSILON (type_traits::type_sqrt (boost::math::tools::epsilon ()))\n#define BOOST_UBLAS_TYPE_CHECK_MIN (type_traits::type_sqrt ( boost::math::tools::min_value()))\n#define BOOST_UBLAS_NDEBUG\n\n#include \nnamespace std{\nusing boost::math::ntl::pow;\n} // workaround for spirit parser.\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include // for test_main\n\nextern boost::math::ntl::RR f(const boost::math::ntl::RR& x, int variant);\nextern void show_extra(\n const boost::math::tools::polynomial& n, \n const boost::math::tools::polynomial& d, \n const boost::math::ntl::RR& x_offset, \n const boost::math::ntl::RR& y_offset, \n int variant);\n\nusing namespace boost::spirit::classic;\n\nboost::math::ntl::RR a(0), b(1); // range to optimise over\nbool rel_error(true);\nbool pin(false);\nint orderN(3);\nint orderD(1);\nint target_precision = boost::math::tools::digits();\nint working_precision = target_precision * 2;\nbool started(false);\nint variant(0);\nint skew(0);\nint brake(50);\nboost::math::ntl::RR x_offset(0), y_offset(0), x_scale(1);\nbool auto_offset_y;\n\nboost::shared_ptr > p_remez;\n\nboost::math::ntl::RR the_function(const boost::math::ntl::RR& val)\n{\n return f(x_scale * (val + x_offset), variant) + y_offset;\n}\n\nvoid step_some(unsigned count)\n{\n try{\n NTL::RR::SetPrecision(working_precision);\n if(!started)\n {\n //\n // If we have an automatic y-offset calculate it now:\n //\n if(auto_offset_y)\n {\n boost::math::ntl::RR fa, fb, fm;\n fa = f(x_scale * (a + x_offset), variant);\n fb = f(x_scale * (b + x_offset), variant);\n fm = f(x_scale * ((a+b)/2 + x_offset), variant);\n y_offset = -(fa + fb + fm) / 3;\n NTL::RR::SetOutputPrecision(5);\n std::cout << \"Setting auto-y-offset to \" << y_offset << std::endl;\n }\n //\n // Truncate offsets to float precision:\n //\n x_offset = NTL::RoundToPrecision(x_offset.value(), 20);\n y_offset = NTL::RoundToPrecision(y_offset.value(), 20);\n //\n // Construct new Remez state machine:\n //\n p_remez.reset(new boost::math::tools::remez_minimax(\n &the_function, \n orderN, orderD, \n a, b, \n pin, \n rel_error, \n skew, \n working_precision));\n std::cout << \"Max error in interpolated form: \" << std::setprecision(3) << std::scientific << boost::math::tools::real_cast(p_remez->max_error()) << std::endl;\n //\n // Signal that we've started:\n //\n started = true;\n }\n unsigned i;\n for(i = 0; i < count; ++i)\n {\n std::cout << \"Stepping...\" << std::endl;\n p_remez->set_brake(brake);\n boost::math::ntl::RR r = p_remez->iterate();\n NTL::RR::SetOutputPrecision(3);\n std::cout \n << \"Maximum Deviation Found: \" << std::setprecision(3) << std::scientific << boost::math::tools::real_cast(p_remez->max_error()) << std::endl\n << \"Expected Error Term: \" << std::setprecision(3) << std::scientific << boost::math::tools::real_cast(p_remez->error_term()) << std::endl\n << \"Maximum Relative Change in Control Points: \" << std::setprecision(3) << std::scientific << boost::math::tools::real_cast(r) << std::endl;\n }\n }\n catch(const std::exception& e)\n {\n std::cout << \"Step failed with exception: \" << e.what() << std::endl;\n }\n}\n\nvoid step(const char*, const char*)\n{\n step_some(1);\n}\n\nvoid show(const char*, const char*)\n{\n NTL::RR::SetPrecision(working_precision);\n if(started)\n {\n boost::math::tools::polynomial n = p_remez->numerator();\n boost::math::tools::polynomial d = p_remez->denominator();\n std::vector cn = n.chebyshev();\n std::vector cd = d.chebyshev();\n int prec = 2 + (target_precision * 3010LL)/10000;\n std::cout << std::scientific << std::setprecision(prec);\n NTL::RR::SetOutputPrecision(prec);\n boost::numeric::ublas::vector v = p_remez->zero_points();\n \n std::cout << \" Zeros = {\\n\";\n unsigned i;\n for(i = 0; i < v.size(); ++i)\n {\n std::cout << \" \" << v[i] << std::endl;\n }\n std::cout << \" }\\n\";\n\n v = p_remez->chebyshev_points();\n std::cout << \" Chebeshev Control Points = {\\n\";\n for(i = 0; i < v.size(); ++i)\n {\n std::cout << \" \" << v[i] << std::endl;\n }\n std::cout << \" }\\n\";\n\n std::cout << \"X offset: \" << x_offset << std::endl;\n std::cout << \"X scale: \" << x_scale << std::endl;\n std::cout << \"Y offset: \" << y_offset << std::endl;\n\n std::cout << \"P = {\";\n for(i = 0; i < n.size(); ++i)\n {\n std::cout << \" \" << n[i] << \"L,\" << std::endl;\n }\n std::cout << \" }\\n\";\n\n std::cout << \"Q = {\";\n for(i = 0; i < d.size(); ++i)\n {\n std::cout << \" \" << d[i] << \"L,\" << std::endl;\n }\n std::cout << \" }\\n\";\n\n std::cout << \"CP = {\";\n for(i = 0; i < cn.size(); ++i)\n {\n std::cout << \" \" << cn[i] << \"L,\" << std::endl;\n }\n std::cout << \" }\\n\";\n\n std::cout << \"CQ = {\";\n for(i = 0; i < cd.size(); ++i)\n {\n std::cout << \" \" << cd[i] << \"L,\" << std::endl;\n }\n std::cout << \" }\\n\";\n\n show_extra(n, d, x_offset, y_offset, variant);\n }\n else\n {\n std::cerr << \"Nothing to display\" << std::endl;\n }\n}\n\nvoid do_graph(unsigned points)\n{\n NTL::RR::SetPrecision(working_precision);\n boost::math::ntl::RR step = (b - a) / (points - 1);\n boost::math::ntl::RR x = a;\n while(points > 1)\n {\n NTL::RR::SetOutputPrecision(10);\n std::cout << std::setprecision(10) << std::setw(30) << std::left \n << boost::lexical_cast(x) << the_function(x) << std::endl;\n --points;\n x += step;\n }\n std::cout << std::setprecision(10) << std::setw(30) << std::left \n << boost::lexical_cast(b) << the_function(b) << std::endl;\n}\n\nvoid graph(const char*, const char*)\n{\n do_graph(3);\n}\n\ntemplate \nvoid do_test(T, const char* name)\n{\n boost::math::ntl::RR::SetPrecision(working_precision);\n if(started)\n {\n //\n // We want to test the approximation at fixed precision:\n // either float, double or long double. Begin by getting the\n // polynomials:\n //\n boost::math::tools::polynomial n, d;\n boost::math::tools::polynomial nr, dr;\n nr = p_remez->numerator();\n dr = p_remez->denominator();\n n = nr;\n d = dr;\n\n std::vector cn1, cd1;\n cn1 = nr.chebyshev();\n cd1 = dr.chebyshev();\n std::vector cn, cd;\n for(unsigned i = 0; i < cn1.size(); ++i)\n {\n cn.push_back(boost::math::tools::real_cast(cn1[i]));\n }\n for(unsigned i = 0; i < cd1.size(); ++i)\n {\n cd.push_back(boost::math::tools::real_cast(cd1[i]));\n }\n //\n // We'll test at the Chebeshev control points which is where\n // (in theory) the largest deviation should occur. For good\n // measure we'll test at the zeros as well:\n //\n boost::numeric::ublas::vector \n zeros(p_remez->zero_points()),\n cheb(p_remez->chebyshev_points());\n\n boost::math::ntl::RR max_error(0), cheb_max_error(0);\n\n //\n // Do the tests at the zeros:\n //\n std::cout << \"Starting tests at \" << name << \" precision...\\n\";\n std::cout << \"Absissa Error (Poly) Error (Cheb)\\n\";\n for(unsigned i = 0; i < zeros.size(); ++i)\n {\n boost::math::ntl::RR true_result = the_function(zeros[i]);\n T absissa = boost::math::tools::real_cast(zeros[i]);\n boost::math::ntl::RR test_result = n.evaluate(absissa) / d.evaluate(absissa);\n boost::math::ntl::RR cheb_result = boost::math::tools::evaluate_chebyshev(cn, absissa) / boost::math::tools::evaluate_chebyshev(cd, absissa);\n boost::math::ntl::RR err, cheb_err;\n if(rel_error)\n {\n err = boost::math::tools::relative_error(test_result, true_result);\n cheb_err = boost::math::tools::relative_error(cheb_result, true_result);\n }\n else\n {\n err = fabs(test_result - true_result);\n cheb_err = fabs(cheb_result - true_result);\n }\n if(err > max_error)\n max_error = err;\n if(cheb_err > cheb_max_error)\n cheb_max_error = cheb_err;\n std::cout << std::setprecision(6) << std::setw(15) << std::left << absissa\n << std::setw(15) << std::left << boost::math::tools::real_cast(err) << boost::math::tools::real_cast(cheb_err) << std::endl;\n }\n //\n // Do the tests at the Chebeshev control points:\n //\n for(unsigned i = 0; i < cheb.size(); ++i)\n {\n boost::math::ntl::RR true_result = the_function(cheb[i]);\n T absissa = boost::math::tools::real_cast(cheb[i]);\n boost::math::ntl::RR test_result = n.evaluate(absissa) / d.evaluate(absissa);\n boost::math::ntl::RR cheb_result = boost::math::tools::evaluate_chebyshev(cn, absissa) / boost::math::tools::evaluate_chebyshev(cd, absissa);\n boost::math::ntl::RR err, cheb_err;\n if(rel_error)\n {\n err = boost::math::tools::relative_error(test_result, true_result);\n cheb_err = boost::math::tools::relative_error(cheb_result, true_result);\n }\n else\n {\n err = fabs(test_result - true_result);\n cheb_err = fabs(cheb_result - true_result);\n }\n if(err > max_error)\n max_error = err;\n std::cout << std::setprecision(6) << std::setw(15) << std::left << absissa\n << std::setw(15) << std::left << boost::math::tools::real_cast(err) << \n boost::math::tools::real_cast(cheb_err) << std::endl;\n }\n std::string msg = \"Max Error found at \";\n msg += name;\n msg += \" precision = \";\n msg.append(62 - 17 - msg.size(), ' ');\n std::cout << msg << std::setprecision(6) << \"Poly: \" << std::setw(20) << std::left\n << boost::math::tools::real_cast(max_error) << \"Cheb: \" << boost::math::tools::real_cast(cheb_max_error) << std::endl;\n }\n else\n {\n std::cout << \"Nothing to test: try converging an approximation first!!!\" << std::endl;\n }\n}\n\nvoid test_float(const char*, const char*)\n{\n do_test(float(0), \"float\");\n}\n\nvoid test_double(const char*, const char*)\n{\n do_test(double(0), \"double\");\n}\n\nvoid test_long(const char*, const char*)\n{\n do_test((long double)(0), \"long double\");\n}\n\nvoid test_all(const char*, const char*)\n{\n do_test(float(0), \"float\");\n do_test(double(0), \"double\");\n do_test((long double)(0), \"long double\");\n}\n\ntemplate \nvoid do_test_n(T, const char* name, unsigned count)\n{\n boost::math::ntl::RR::SetPrecision(working_precision);\n if(started)\n {\n //\n // We want to test the approximation at fixed precision:\n // either float, double or long double. Begin by getting the\n // polynomials:\n //\n boost::math::tools::polynomial n, d;\n boost::math::tools::polynomial nr, dr;\n nr = p_remez->numerator();\n dr = p_remez->denominator();\n n = nr;\n d = dr;\n\n std::vector cn1, cd1;\n cn1 = nr.chebyshev();\n cd1 = dr.chebyshev();\n std::vector cn, cd;\n for(unsigned i = 0; i < cn1.size(); ++i)\n {\n cn.push_back(boost::math::tools::real_cast(cn1[i]));\n }\n for(unsigned i = 0; i < cd1.size(); ++i)\n {\n cd.push_back(boost::math::tools::real_cast(cd1[i]));\n }\n\n boost::math::ntl::RR max_error(0), max_cheb_error(0);\n boost::math::ntl::RR step = (b - a) / count;\n\n //\n // Do the tests at the zeros:\n //\n std::cout << \"Starting tests at \" << name << \" precision...\\n\";\n std::cout << \"Absissa Error (poly) Error (Cheb)\\n\";\n for(boost::math::ntl::RR x = a; x <= b; x += step)\n {\n boost::math::ntl::RR true_result = the_function(x);\n T absissa = boost::math::tools::real_cast(x);\n boost::math::ntl::RR test_result = n.evaluate(absissa) / d.evaluate(absissa);\n boost::math::ntl::RR cheb_result = boost::math::tools::evaluate_chebyshev(cn, absissa) / boost::math::tools::evaluate_chebyshev(cd, absissa);\n boost::math::ntl::RR err, cheb_err;\n if(rel_error)\n {\n err = boost::math::tools::relative_error(test_result, true_result);\n cheb_err = boost::math::tools::relative_error(cheb_result, true_result);\n }\n else\n {\n err = fabs(test_result - true_result);\n cheb_err = fabs(cheb_result - true_result);\n }\n if(err > max_error)\n max_error = err;\n if(cheb_err > max_cheb_error)\n max_cheb_error = cheb_err;\n std::cout << std::setprecision(6) << std::setw(15) << std::left << boost::math::tools::real_cast(absissa)\n << (test_result < true_result ? \"-\" : \"\") << std::setw(20) << std::left \n << boost::math::tools::real_cast(err) \n << boost::math::tools::real_cast(cheb_err) << std::endl;\n }\n std::string msg = \"Max Error found at \";\n msg += name;\n msg += \" precision = \";\n //msg.append(62 - 17 - msg.size(), ' ');\n std::cout << msg << \"Poly: \" << std::setprecision(6) \n //<< std::setw(15) << std::left \n << boost::math::tools::real_cast(max_error) \n << \" Cheb: \" << boost::math::tools::real_cast(max_cheb_error) << std::endl;\n }\n else\n {\n std::cout << \"Nothing to test: try converging an approximation first!!!\" << std::endl;\n }\n}\n\nvoid test_n(unsigned n)\n{\n do_test_n(boost::math::ntl::RR(), \"boost::math::ntl::RR\", n);\n}\n\nvoid test_float_n(unsigned n)\n{\n do_test_n(float(0), \"float\", n);\n}\n\nvoid test_double_n(unsigned n)\n{\n do_test_n(double(0), \"double\", n);\n}\n\nvoid test_long_n(unsigned n)\n{\n do_test_n((long double)(0), \"long double\", n);\n}\n\nvoid rotate(const char*, const char*)\n{\n if(p_remez)\n {\n p_remez->rotate();\n }\n else\n {\n std::cerr << \"Nothing to rotate\" << std::endl;\n }\n}\n\nvoid rescale(const char*, const char*)\n{\n if(p_remez)\n {\n p_remez->rescale(a, b);\n }\n else\n {\n std::cerr << \"Nothing to rescale\" << std::endl;\n }\n}\n\nvoid graph_poly(const char*, const char*)\n{\n int i = 50;\n boost::math::ntl::RR::SetPrecision(working_precision);\n if(started)\n {\n //\n // We want to test the approximation at fixed precision:\n // either float, double or long double. Begin by getting the\n // polynomials:\n //\n boost::math::tools::polynomial n, d;\n n = p_remez->numerator();\n d = p_remez->denominator();\n\n boost::math::ntl::RR max_error(0);\n boost::math::ntl::RR step = (b - a) / i;\n\n std::cout << \"Evaluating Numerator...\\n\";\n boost::math::ntl::RR val;\n for(val = a; val <= b; val += step)\n std::cout << n.evaluate(val) << std::endl;\n std::cout << \"Evaluating Denominator...\\n\";\n for(val = a; val <= b; val += step)\n std::cout << d.evaluate(val) << std::endl;\n }\n else\n {\n std::cout << \"Nothing to test: try converging an approximation first!!!\" << std::endl;\n }\n}\n\nint test_main(int, char* [])\n{\n std::string line;\n real_parser const rr_p;\n while(std::getline(std::cin, line))\n {\n if(parse(line.c_str(), str_p(\"quit\"), space_p).full)\n return 0;\n if(false == parse(line.c_str(), \n (\n\n str_p(\"range\")[assign_a(started, false)] && real_p[assign_a(a)] && real_p[assign_a(b)]\n ||\n str_p(\"relative\")[assign_a(started, false)][assign_a(rel_error, true)]\n ||\n str_p(\"absolute\")[assign_a(started, false)][assign_a(rel_error, false)]\n ||\n str_p(\"pin\")[assign_a(started, false)] && str_p(\"true\")[assign_a(pin, true)]\n ||\n str_p(\"pin\")[assign_a(started, false)] && str_p(\"false\")[assign_a(pin, false)]\n ||\n str_p(\"pin\")[assign_a(started, false)] && str_p(\"1\")[assign_a(pin, true)]\n ||\n str_p(\"pin\")[assign_a(started, false)] && str_p(\"0\")[assign_a(pin, false)]\n ||\n str_p(\"pin\")[assign_a(started, false)][assign_a(pin, true)]\n ||\n str_p(\"order\")[assign_a(started, false)] && uint_p[assign_a(orderN)] && uint_p[assign_a(orderD)]\n ||\n str_p(\"order\")[assign_a(started, false)] && uint_p[assign_a(orderN)]\n ||\n str_p(\"target-precision\") && uint_p[assign_a(target_precision)]\n ||\n str_p(\"working-precision\")[assign_a(started, false)] && uint_p[assign_a(working_precision)]\n ||\n str_p(\"variant\")[assign_a(started, false)] && int_p[assign_a(variant)]\n ||\n str_p(\"skew\")[assign_a(started, false)] && int_p[assign_a(skew)]\n ||\n str_p(\"brake\") && int_p[assign_a(brake)]\n ||\n str_p(\"step\") && int_p[&step_some]\n ||\n str_p(\"step\")[&step]\n ||\n str_p(\"poly\")[&graph_poly]\n ||\n str_p(\"info\")[&show]\n ||\n str_p(\"graph\") && uint_p[&do_graph]\n ||\n str_p(\"graph\")[&graph]\n ||\n str_p(\"x-offset\") && real_p[assign_a(x_offset)]\n ||\n str_p(\"x-scale\") && real_p[assign_a(x_scale)]\n ||\n str_p(\"y-offset\") && str_p(\"auto\")[assign_a(auto_offset_y, true)]\n ||\n str_p(\"y-offset\") && real_p[assign_a(y_offset)][assign_a(auto_offset_y, false)]\n ||\n str_p(\"test\") && str_p(\"float\") && uint_p[&test_float_n]\n ||\n str_p(\"test\") && str_p(\"float\")[&test_float]\n ||\n str_p(\"test\") && str_p(\"double\") && uint_p[&test_double_n]\n ||\n str_p(\"test\") && str_p(\"double\")[&test_double]\n ||\n str_p(\"test\") && str_p(\"long\") && uint_p[&test_long_n]\n ||\n str_p(\"test\") && str_p(\"long\")[&test_long]\n ||\n str_p(\"test\") && str_p(\"all\")[&test_all]\n ||\n str_p(\"test\") && uint_p[&test_n]\n ||\n str_p(\"rotate\")[&rotate]\n ||\n str_p(\"rescale\") && real_p[assign_a(a)] && real_p[assign_a(b)] && epsilon_p[&rescale]\n\n ), space_p).full)\n {\n std::cout << \"Unable to parse directive: \\\"\" << line << \"\\\"\" << std::endl;\n }\n else\n {\n std::cout << \"Variant = \" << variant << std::endl;\n std::cout << \"range = [\" << a << \",\" << b << \"]\" << std::endl;\n std::cout << \"Relative Error = \" << rel_error << std::endl;\n std::cout << \"Pin to Origin = \" << pin << std::endl;\n std::cout << \"Order (Num/Denom) = \" << orderN << \"/\" << orderD << std::endl;\n std::cout << \"Target Precision = \" << target_precision << std::endl;\n std::cout << \"Working Precision = \" << working_precision << std::endl;\n std::cout << \"Skew = \" << skew << std::endl;\n std::cout << \"Brake = \" << brake << std::endl;\n std::cout << \"X Offset = \" << x_offset << std::endl;\n std::cout << \"X scale = \" << x_scale << std::endl;\n std::cout << \"Y Offset = \";\n if(auto_offset_y)\n std::cout << \"Auto (\";\n std::cout << y_offset;\n if(auto_offset_y)\n std::cout << \")\";\n std::cout << std::endl;\n }\n }\n return 0;\n}\n", "meta": {"hexsha": "8d8ab324a89c3b7fa007c1fa022740f3f293d111", "size": 20787, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/math/minimax/main.cpp", "max_stars_repo_name": "ai-nikolaev/repo-cppboost", "max_stars_repo_head_hexsha": "218c4a977c6d8cd6f2864cdcea1b6ab53160d203", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2016-04-12T16:29:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-28T11:01:57.000Z", "max_issues_repo_path": "libs/math/minimax/main.cpp", "max_issues_repo_name": "ai-nikolaev/repo-cppboost", "max_issues_repo_head_hexsha": "218c4a977c6d8cd6f2864cdcea1b6ab53160d203", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2018-10-31T19:35:14.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-04T17:11:27.000Z", "max_forks_repo_path": "libs/math/minimax/main.cpp", "max_forks_repo_name": "ai-nikolaev/repo-cppboost", "max_forks_repo_head_hexsha": "218c4a977c6d8cd6f2864cdcea1b6ab53160d203", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 9.0, "max_forks_repo_forks_event_min_datetime": "2015-09-09T02:38:32.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-30T00:24:24.000Z", "avg_line_length": 34.1330049261, "max_line_length": 182, "alphanum_fraction": 0.5426468466, "num_tokens": 5826, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506418255927, "lm_q2_score": 0.6548947155710233, "lm_q1q2_score": 0.49814608572728786}} {"text": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech Research Corporation,\n * Atlanta, Georgia 30332-0415\n * All Rights Reserved\n * Authors: Frank Dellaert, et al. (see THANKS for the full author list)\n\n * See LICENSE for the license information\n\n * -------------------------------------------------------------------------- */\n\n/**\n * @file InitializePose3.h\n * @author Luca Carlone\n * @author Frank Dellaert\n * @date August, 2014\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nusing namespace std;\n\nnamespace gtsam {\nnamespace InitializePose3 {\n\nstatic const Matrix I9 = I_9x9;\nstatic const Vector zero9 = Vector::Zero(9);\nstatic const Matrix zero33 = Z_3x3;\n\nstatic const Key keyAnchor = symbol('Z', 9999999);\n\n/* ************************************************************************* */\nGaussianFactorGraph buildLinearOrientationGraph(const NonlinearFactorGraph& g) {\n\n GaussianFactorGraph linearGraph;\n noiseModel::Unit::shared_ptr model = noiseModel::Unit::Create(9);\n\n for(const boost::shared_ptr& factor: g) {\n Matrix3 Rij;\n\n boost::shared_ptr > pose3Between =\n boost::dynamic_pointer_cast >(factor);\n if (pose3Between)\n Rij = pose3Between->measured().rotation().matrix();\n else\n std::cout << \"Error in buildLinearOrientationGraph\" << std::endl;\n\n const FastVector& keys = factor->keys();\n Key key1 = keys[0], key2 = keys[1];\n Matrix M9 = Z_9x9;\n M9.block(0,0,3,3) = Rij;\n M9.block(3,3,3,3) = Rij;\n M9.block(6,6,3,3) = Rij;\n linearGraph.add(key1, -I9, key2, M9, zero9, model);\n }\n // prior on the anchor orientation\n linearGraph.add(keyAnchor, I9, (Vector(9) << 1.0, 0.0, 0.0,/* */ 0.0, 1.0, 0.0, /* */ 0.0, 0.0, 1.0).finished(), model);\n return linearGraph;\n}\n\n/* ************************************************************************* */\n// Transform VectorValues into valid Rot3\nValues normalizeRelaxedRotations(const VectorValues& relaxedRot3) {\n gttic(InitializePose3_computeOrientationsChordal);\n\n Matrix ppm = Z_3x3; // plus plus minus\n ppm(0,0) = 1; ppm(1,1) = 1; ppm(2,2) = -1;\n\n Values validRot3;\n for(const VectorValues::value_type& it: relaxedRot3) {\n Key key = it.first;\n if (key != keyAnchor) {\n const Vector& rotVector = it.second;\n Matrix3 rotMat;\n rotMat(0,0) = rotVector(0); rotMat(0,1) = rotVector(1); rotMat(0,2) = rotVector(2);\n rotMat(1,0) = rotVector(3); rotMat(1,1) = rotVector(4); rotMat(1,2) = rotVector(5);\n rotMat(2,0) = rotVector(6); rotMat(2,1) = rotVector(7); rotMat(2,2) = rotVector(8);\n\n Matrix U, V; Vector s;\n svd(rotMat, U, s, V);\n Matrix3 normalizedRotMat = U * V.transpose();\n\n // std::cout << \"rotMat \\n\" << rotMat << std::endl;\n // std::cout << \"U V' \\n\" << U * V.transpose() << std::endl;\n // std::cout << \"V \\n\" << V << std::endl;\n\n if(normalizedRotMat.determinant() < 0)\n normalizedRotMat = U * ppm * V.transpose();\n\n Rot3 initRot = Rot3(normalizedRotMat);\n validRot3.insert(key, initRot);\n }\n }\n return validRot3;\n}\n\n/* ************************************************************************* */\n// Select the subgraph of betweenFactors and transforms priors into between wrt a fictitious node\nNonlinearFactorGraph buildPose3graph(const NonlinearFactorGraph& graph) {\n gttic(InitializePose3_buildPose3graph);\n NonlinearFactorGraph pose3Graph;\n\n for(const boost::shared_ptr& factor: graph) {\n\n // recast to a between on Pose3\n boost::shared_ptr > pose3Between =\n boost::dynamic_pointer_cast >(factor);\n if (pose3Between)\n pose3Graph.add(pose3Between);\n\n // recast PriorFactor to BetweenFactor\n boost::shared_ptr > pose3Prior =\n boost::dynamic_pointer_cast >(factor);\n if (pose3Prior)\n pose3Graph.emplace_shared >(keyAnchor, pose3Prior->keys()[0],\n pose3Prior->prior(), pose3Prior->noiseModel());\n }\n return pose3Graph;\n}\n\n/* ************************************************************************* */\n// Return the orientations of a graph including only BetweenFactors\nValues computeOrientationsChordal(const NonlinearFactorGraph& pose3Graph) {\n gttic(InitializePose3_computeOrientationsChordal);\n\n // regularize measurements and plug everything in a factor graph\n GaussianFactorGraph relaxedGraph = buildLinearOrientationGraph(pose3Graph);\n\n // Solve the LFG\n VectorValues relaxedRot3 = relaxedGraph.optimize();\n\n // normalize and compute Rot3\n return normalizeRelaxedRotations(relaxedRot3);\n}\n\n/* ************************************************************************* */\n// Return the orientations of a graph including only BetweenFactors\nValues computeOrientationsGradient(const NonlinearFactorGraph& pose3Graph, const Values& givenGuess, const size_t maxIter, const bool setRefFrame) {\n gttic(InitializePose3_computeOrientationsGradient);\n\n // this works on the inverse rotations, according to Tron&Vidal,2011\n Values inverseRot;\n inverseRot.insert(keyAnchor, Rot3());\n for(const Values::ConstKeyValuePair& key_value: givenGuess) {\n Key key = key_value.key;\n const Pose3& pose = givenGuess.at(key);\n inverseRot.insert(key, pose.rotation().inverse());\n }\n\n // Create the map of edges incident on each node\n KeyVectorMap adjEdgesMap;\n KeyRotMap factorId2RotMap;\n\n createSymbolicGraph(adjEdgesMap, factorId2RotMap, pose3Graph);\n\n // calculate max node degree & allocate gradient\n size_t maxNodeDeg = 0;\n VectorValues grad;\n for(const Values::ConstKeyValuePair& key_value: inverseRot) {\n Key key = key_value.key;\n grad.insert(key,Vector3::Zero());\n size_t currNodeDeg = (adjEdgesMap.at(key)).size();\n if(currNodeDeg > maxNodeDeg)\n maxNodeDeg = currNodeDeg;\n }\n\n // Create parameters\n double b = 1;\n double f0 = 1/b - (1/b + M_PI) * exp(-b*M_PI);\n double a = (M_PI*M_PI)/(2*f0);\n double rho = 2*a*b;\n double mu_max = maxNodeDeg * rho;\n double stepsize = 2/mu_max; // = 1/(a b dG)\n\n std::cout <<\" b \" << b <<\" f0 \" << f0 <<\" a \" << a <<\" rho \" << rho <<\" stepsize \" << stepsize << \" maxNodeDeg \"<< maxNodeDeg << std::endl;\n double maxGrad;\n // gradient iterations\n size_t it;\n for(it=0; it < maxIter; it++){\n //////////////////////////////////////////////////////////////////////////\n // compute the gradient at each node\n //std::cout << \"it \" << it <<\" b \" << b <<\" f0 \" << f0 <<\" a \" << a\n // <<\" rho \" << rho <<\" stepsize \" << stepsize << \" maxNodeDeg \"<< maxNodeDeg << std::endl;\n maxGrad = 0;\n for(const Values::ConstKeyValuePair& key_value: inverseRot) {\n Key key = key_value.key;\n //std::cout << \"---------------------------key \" << DefaultKeyFormatter(key) << std::endl;\n Vector gradKey = Vector3::Zero();\n // collect the gradient for each edge incident on key\n for(const size_t& factorId: adjEdgesMap.at(key)){\n Rot3 Rij = factorId2RotMap.at(factorId);\n Rot3 Ri = inverseRot.at(key);\n if( key == (pose3Graph.at(factorId))->keys()[0] ){\n Key key1 = (pose3Graph.at(factorId))->keys()[1];\n Rot3 Rj = inverseRot.at(key1);\n gradKey = gradKey + gradientTron(Ri, Rij * Rj, a, b);\n //std::cout << \"key1 \" << DefaultKeyFormatter(key1) << \" gradientTron(Ri, Rij * Rj, a, b) \\n \" << gradientTron(Ri, Rij * Rj, a, b) << std::endl;\n }else if( key == (pose3Graph.at(factorId))->keys()[1] ){\n Key key0 = (pose3Graph.at(factorId))->keys()[0];\n Rot3 Rj = inverseRot.at(key0);\n gradKey = gradKey + gradientTron(Ri, Rij.between(Rj), a, b);\n //std::cout << \"key0 \" << DefaultKeyFormatter(key0) << \" gradientTron(Ri, Rij.inverse() * Rj, a, b) \\n \" << gradientTron(Ri, Rij.between(Rj), a, b) << std::endl;\n }else{\n std::cout << \"Error in gradient computation\" << std::endl;\n }\n } // end of i-th gradient computation\n grad.at(key) = stepsize * gradKey;\n\n double normGradKey = (gradKey).norm();\n //std::cout << \"key \" << DefaultKeyFormatter(key) <<\" \\n grad \\n\" << grad.at(key) << std::endl;\n if(normGradKey>maxGrad)\n maxGrad = normGradKey;\n } // end of loop over nodes\n\n //////////////////////////////////////////////////////////////////////////\n // update estimates\n inverseRot = inverseRot.retract(grad);\n\n //////////////////////////////////////////////////////////////////////////\n // check stopping condition\n if (it>20 && maxGrad < 5e-3)\n break;\n } // enf of gradient iterations\n\n std::cout << \"nr of gradient iterations \" << it << \"maxGrad \" << maxGrad << std::endl;\n\n // Return correct rotations\n const Rot3& Rref = inverseRot.at(keyAnchor); // This will be set to the identity as so far we included no prior\n Values estimateRot;\n for(const Values::ConstKeyValuePair& key_value: inverseRot) {\n Key key = key_value.key;\n if (key != keyAnchor) {\n const Rot3& R = inverseRot.at(key);\n if(setRefFrame)\n estimateRot.insert(key, Rref.compose(R.inverse()));\n else\n estimateRot.insert(key, R.inverse());\n }\n }\n return estimateRot;\n}\n\n/* ************************************************************************* */\nvoid createSymbolicGraph(KeyVectorMap& adjEdgesMap, KeyRotMap& factorId2RotMap, const NonlinearFactorGraph& pose3Graph){\n size_t factorId = 0;\n for(const boost::shared_ptr& factor: pose3Graph) {\n boost::shared_ptr > pose3Between =\n boost::dynamic_pointer_cast >(factor);\n if (pose3Between){\n Rot3 Rij = pose3Between->measured().rotation();\n factorId2RotMap.insert(pair(factorId,Rij));\n\n Key key1 = pose3Between->key1();\n if (adjEdgesMap.find(key1) != adjEdgesMap.end()){ // key is already in\n adjEdgesMap.at(key1).push_back(factorId);\n }else{\n vector edge_id;\n edge_id.push_back(factorId);\n adjEdgesMap.insert(pair >(key1, edge_id));\n }\n Key key2 = pose3Between->key2();\n if (adjEdgesMap.find(key2) != adjEdgesMap.end()){ // key is already in\n adjEdgesMap.at(key2).push_back(factorId);\n }else{\n vector edge_id;\n edge_id.push_back(factorId);\n adjEdgesMap.insert(pair >(key2, edge_id));\n }\n }else{\n std::cout << \"Error in computeOrientationsGradient\" << std::endl;\n }\n factorId++;\n }\n}\n\n/* ************************************************************************* */\nVector3 gradientTron(const Rot3& R1, const Rot3& R2, const double a, const double b) {\n Vector3 logRot = Rot3::Logmap(R1.between(R2));\n\n double th = logRot.norm();\n if(th != th){ // the second case means that th = nan (logRot does not work well for +/-pi)\n Rot3 R1pert = R1.compose( Rot3::Expmap(Vector3(0.01, 0.01, 0.01)) ); // some perturbation\n logRot = Rot3::Logmap(R1pert.between(R2));\n th = logRot.norm();\n }\n // exclude small or invalid rotations\n if (th > 1e-5 && th == th){ // nonzero valid rotations\n logRot = logRot / th;\n }else{\n logRot = Vector3::Zero();\n th = 0.0;\n }\n\n double fdot = a*b*th*exp(-b*th);\n return fdot*logRot;\n}\n\n/* ************************************************************************* */\nValues initializeOrientations(const NonlinearFactorGraph& graph) {\n\n // We \"extract\" the Pose3 subgraph of the original graph: this\n // is done to properly model priors and avoiding operating on a larger graph\n NonlinearFactorGraph pose3Graph = buildPose3graph(graph);\n\n // Get orientations from relative orientation measurements\n return computeOrientationsChordal(pose3Graph);\n}\n\n///* ************************************************************************* */\nValues computePoses(NonlinearFactorGraph& pose3graph, Values& initialRot) {\n gttic(InitializePose3_computePoses);\n\n // put into Values structure\n Values initialPose;\n for(const Values::ConstKeyValuePair& key_value: initialRot){\n Key key = key_value.key;\n const Rot3& rot = initialRot.at(key);\n Pose3 initializedPose = Pose3(rot, Point3(0, 0, 0));\n initialPose.insert(key, initializedPose);\n }\n // add prior\n noiseModel::Unit::shared_ptr priorModel = noiseModel::Unit::Create(6);\n initialPose.insert(keyAnchor, Pose3());\n pose3graph.emplace_shared >(keyAnchor, Pose3(), priorModel);\n\n // Create optimizer\n GaussNewtonParams params;\n bool singleIter = true;\n if(singleIter){\n params.maxIterations = 1;\n }else{\n std::cout << \" \\n\\n\\n\\n performing more than 1 GN iterations \\n\\n\\n\" <(key);\n estimate.insert(key, pose);\n }\n }\n return estimate;\n}\n\n/* ************************************************************************* */\nValues initialize(const NonlinearFactorGraph& graph) {\n gttic(InitializePose3_initialize);\n\n // We \"extract\" the Pose3 subgraph of the original graph: this\n // is done to properly model priors and avoiding operating on a larger graph\n NonlinearFactorGraph pose3Graph = buildPose3graph(graph);\n\n // Get orientations from relative orientation measurements\n Values valueRot3 = computeOrientationsChordal(pose3Graph);\n\n // Compute the full poses (1 GN iteration on full poses)\n return computePoses(pose3Graph, valueRot3);\n}\n\n/* ************************************************************************* */\nValues initialize(const NonlinearFactorGraph& graph, const Values& givenGuess, bool useGradient) {\n Values initialValues;\n\n // We \"extract\" the Pose3 subgraph of the original graph: this\n // is done to properly model priors and avoiding operating on a larger graph\n NonlinearFactorGraph pose3Graph = buildPose3graph(graph);\n\n // Get orientations from relative orientation measurements\n Values orientations;\n if(useGradient)\n orientations = computeOrientationsGradient(pose3Graph, givenGuess);\n else\n orientations = computeOrientationsChordal(pose3Graph);\n\n// orientations.print(\"orientations\\n\");\n\n // Compute the full poses (1 GN iteration on full poses)\n return computePoses(pose3Graph, orientations);\n\n // for(const Values::ConstKeyValuePair& key_value: orientations) {\n // Key key = key_value.key;\n // if (key != keyAnchor) {\n // const Point3& pos = givenGuess.at(key).translation();\n // const Rot3& rot = orientations.at(key);\n // Pose3 initializedPoses = Pose3(rot, pos);\n // initialValues.insert(key, initializedPoses);\n // }\n // }\n // return initialValues;\n}\n\n} // end of namespace lago\n} // end of namespace gtsam\n", "meta": {"hexsha": "58408e7e32d2915dcd43ed900b96d96e696f94c4", "size": 15436, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "gtsam/slam/InitializePose3.cpp", "max_stars_repo_name": "colinxs/gtsam", "max_stars_repo_head_hexsha": "c6d9baf3ce4b5ced7fec4c52e304a31b8eadffd0", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2019-04-10T03:25:01.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-01T12:10:54.000Z", "max_issues_repo_path": "gtsam/slam/InitializePose3.cpp", "max_issues_repo_name": "colinxs/gtsam", "max_issues_repo_head_hexsha": "c6d9baf3ce4b5ced7fec4c52e304a31b8eadffd0", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2017-12-14T06:41:31.000Z", "max_issues_repo_issues_event_max_datetime": "2017-12-14T06:41:31.000Z", "max_forks_repo_path": "gtsam/slam/InitializePose3.cpp", "max_forks_repo_name": "colinxs/gtsam", "max_forks_repo_head_hexsha": "c6d9baf3ce4b5ced7fec4c52e304a31b8eadffd0", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2020-08-16T17:47:18.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-19T10:36:57.000Z", "avg_line_length": 37.9262899263, "max_line_length": 172, "alphanum_fraction": 0.616934439, "num_tokens": 4111, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7371581741774411, "lm_q2_score": 0.6757646075489391, "lm_q1q2_score": 0.498145404274511}} {"text": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech Research Corporation, \n * Atlanta, Georgia 30332-0415\n * All Rights Reserved\n * Authors: Frank Dellaert, et al. (see THANKS for the full author list)\n\n * See LICENSE for the license information\n\n * -------------------------------------------------------------------------- */\n\n/**\n * @file Pose3.cpp\n * @brief 3D Pose\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nnamespace gtsam {\n\n/** Explicit instantiation of base class to export members */\nINSTANTIATE_LIE(Pose3);\n\n/** instantiate concept checks */\nGTSAM_CONCEPT_POSE_INST(Pose3);\n\nstatic const Matrix3 I3 = eye(3), Z3 = zeros(3, 3), _I3 = -I3;\nstatic const Matrix6 I6 = eye(6);\n\n/* ************************************************************************* */\nPose3::Pose3(const Pose2& pose2) :\n R_(Rot3::rodriguez(0, 0, pose2.theta())), t_(\n Point3(pose2.x(), pose2.y(), 0)) {\n}\n\n/* ************************************************************************* */\n// Calculate Adjoint map\n// Ad_pose is 6*6 matrix that when applied to twist xi, returns Ad_pose(xi)\n// Experimental - unit tests of derivatives based on it do not check out yet\nMatrix6 Pose3::AdjointMap() const {\n const Matrix3 R = R_.matrix();\n const Vector3 t = t_.vector();\n Matrix3 A = skewSymmetric(t) * R;\n Matrix6 adj;\n adj << R, Z3, A, R;\n return adj;\n}\n\n/* ************************************************************************* */\nMatrix6 Pose3::adjointMap(const Vector& xi) {\n Matrix3 w_hat = skewSymmetric(xi(0), xi(1), xi(2));\n Matrix3 v_hat = skewSymmetric(xi(3), xi(4), xi(5));\n Matrix6 adj;\n adj << w_hat, Z3, v_hat, w_hat;\n\n return adj;\n}\n\n/* ************************************************************************* */\nVector Pose3::adjoint(const Vector& xi, const Vector& y,\n boost::optional H) {\n if (H) {\n *H = zeros(6, 6);\n for (int i = 0; i < 6; ++i) {\n Vector dxi = zero(6);\n dxi(i) = 1.0;\n Matrix Gi = adjointMap(dxi);\n (*H).col(i) = Gi * y;\n }\n }\n return adjointMap(xi) * y;\n}\n\n/* ************************************************************************* */\nVector Pose3::adjointTranspose(const Vector& xi, const Vector& y,\n boost::optional H) {\n if (H) {\n *H = zeros(6, 6);\n for (int i = 0; i < 6; ++i) {\n Vector dxi = zero(6);\n dxi(i) = 1.0;\n Matrix GTi = adjointMap(dxi).transpose();\n (*H).col(i) = GTi * y;\n }\n }\n Matrix adjT = adjointMap(xi).transpose();\n return adjointMap(xi).transpose() * y;\n}\n\n/* ************************************************************************* */\nMatrix6 Pose3::dExpInv_exp(const Vector& xi) {\n // Bernoulli numbers, from Wikipedia\n static const Vector B = (Vector(9) << 1.0, -1.0 / 2.0, 1. / 6., 0.0, -1.0 / 30.0,\n 0.0, 1.0 / 42.0, 0.0, -1.0 / 30);\n static const int N = 5; // order of approximation\n Matrix res = I6;\n Matrix6 ad_i = I6;\n Matrix6 ad_xi = adjointMap(xi);\n double fac = 1.0;\n for (int i = 1; i < N; ++i) {\n ad_i = ad_xi * ad_i;\n fac = fac * i;\n res = res + B(i) / fac * ad_i;\n }\n return res;\n}\n\n/* ************************************************************************* */\nvoid Pose3::print(const string& s) const {\n cout << s;\n R_.print(\"R:\\n\");\n t_.print(\"t: \");\n}\n\n/* ************************************************************************* */\nbool Pose3::equals(const Pose3& pose, double tol) const {\n return R_.equals(pose.R_, tol) && t_.equals(pose.t_, tol);\n}\n\n/* ************************************************************************* */\n/** Modified from Murray94book version (which assumes w and v normalized?) */\nPose3 Pose3::Expmap(const Vector& xi) {\n\n // get angular velocity omega and translational velocity v from twist xi\n Point3 w(xi(0), xi(1), xi(2)), v(xi(3), xi(4), xi(5));\n\n double theta = w.norm();\n if (theta < 1e-10) {\n static const Rot3 I;\n return Pose3(I, v);\n } else {\n Point3 n(w / theta); // axis unit vector\n Rot3 R = Rot3::rodriguez(n.vector(), theta);\n double vn = n.dot(v); // translation parallel to n\n Point3 n_cross_v = n.cross(v); // points towards axis\n Point3 t = (n_cross_v - R * n_cross_v) / theta + vn * n;\n return Pose3(R, t);\n }\n}\n\n/* ************************************************************************* */\nVector6 Pose3::Logmap(const Pose3& p) {\n Vector3 w = Rot3::Logmap(p.rotation()), T = p.translation().vector();\n double t = w.norm();\n if (t < 1e-10) {\n Vector6 log;\n log << w, T;\n return log;\n } else {\n Matrix3 W = skewSymmetric(w / t);\n // Formula from Agrawal06iros, equation (14)\n // simplified with Mathematica, and multiplying in T to avoid matrix math\n double Tan = tan(0.5 * t);\n Vector3 WT = W * T;\n Vector3 u = T - (0.5 * t) * WT + (1 - t / (2. * Tan)) * (W * WT);\n Vector6 log;\n log << w, u;\n return log;\n }\n}\n\n/* ************************************************************************* */\nPose3 Pose3::retractFirstOrder(const Vector& xi) const {\n Vector3 omega(sub(xi, 0, 3));\n Point3 v(sub(xi, 3, 6));\n Rot3 R = R_.retract(omega); // R is done exactly\n Point3 t = t_ + R_ * v; // First order t approximation\n return Pose3(R, t);\n}\n\n/* ************************************************************************* */\n// Different versions of retract\nPose3 Pose3::retract(const Vector& xi, Pose3::CoordinatesMode mode) const {\n if (mode == Pose3::EXPMAP) {\n // Lie group exponential map, traces out geodesic\n return compose(Expmap(xi));\n } else if (mode == Pose3::FIRST_ORDER) {\n // First order\n return retractFirstOrder(xi);\n } else {\n // Point3 t = t_.retract(v.vector()); // Incorrect version retracts t independently\n // Point3 t = t_ + R_ * (v+Point3(omega).cross(v)/2); // Second order t approximation\n assert(false);\n exit(1);\n }\n}\n\n/* ************************************************************************* */\n// different versions of localCoordinates\nVector6 Pose3::localCoordinates(const Pose3& T,\n Pose3::CoordinatesMode mode) const {\n if (mode == Pose3::EXPMAP) {\n // Lie group logarithm map, exact inverse of exponential map\n return Logmap(between(T));\n } else if (mode == Pose3::FIRST_ORDER) {\n // R is always done exactly in all three retract versions below\n Vector3 omega = R_.localCoordinates(T.rotation());\n\n // Incorrect version\n // Independently computes the logmap of the translation and rotation\n // Vector v = t_.localCoordinates(T.translation());\n\n // Correct first order t inverse\n Point3 d = R_.unrotate(T.translation() - t_);\n\n // TODO: correct second order t inverse\n Vector6 local;\n local << omega(0), omega(1), omega(2), d.x(), d.y(), d.z();\n return local;\n } else {\n assert(false);\n exit(1);\n }\n}\n\n/* ************************************************************************* */\nMatrix4 Pose3::matrix() const {\n const Matrix3 R = R_.matrix();\n const Vector3 T = t_.vector();\n Eigen::Matrix A14;\n A14 << 0.0, 0.0, 0.0, 1.0;\n Matrix4 mat;\n mat << R, T, A14;\n return mat;\n}\n\n/* ************************************************************************* */\nPose3 Pose3::transform_to(const Pose3& pose) const {\n Rot3 cRv = R_ * Rot3(pose.R_.inverse());\n Point3 t = pose.transform_to(t_);\n return Pose3(cRv, t);\n}\n\n/* ************************************************************************* */\nPoint3 Pose3::transform_from(const Point3& p, boost::optional Dpose,\n boost::optional Dpoint) const {\n if (Dpose) {\n const Matrix R = R_.matrix();\n Matrix DR = R * skewSymmetric(-p.x(), -p.y(), -p.z());\n Dpose->resize(3, 6);\n (*Dpose) << DR, R;\n }\n if (Dpoint)\n *Dpoint = R_.matrix();\n return R_ * p + t_;\n}\n\n/* ************************************************************************* */\nPoint3 Pose3::transform_to(const Point3& p, boost::optional Dpose,\n boost::optional Dpoint) const {\n const Point3 result = R_.unrotate(p - t_);\n if (Dpose) {\n const Point3& q = result;\n Matrix DR = skewSymmetric(q.x(), q.y(), q.z());\n Dpose->resize(3, 6);\n (*Dpose) << DR, _I3;\n }\n if (Dpoint)\n *Dpoint = R_.transpose();\n return result;\n}\n\n/* ************************************************************************* */\nPose3 Pose3::compose(const Pose3& p2, boost::optional H1,\n boost::optional H2) const {\n if (H1)\n *H1 = p2.inverse().AdjointMap();\n if (H2)\n *H2 = I6;\n return (*this) * p2;\n}\n\n/* ************************************************************************* */\nPose3 Pose3::inverse(boost::optional H1) const {\n if (H1)\n *H1 = -AdjointMap();\n Rot3 Rt = R_.inverse();\n return Pose3(Rt, Rt * (-t_));\n}\n\n/* ************************************************************************* */\n// between = compose(p2,inverse(p1));\nPose3 Pose3::between(const Pose3& p2, boost::optional H1,\n boost::optional H2) const {\n Pose3 result = inverse() * p2;\n if (H1)\n *H1 = -result.inverse().AdjointMap();\n if (H2)\n *H2 = I6;\n return result;\n}\n\n/* ************************************************************************* */\ndouble Pose3::range(const Point3& point, boost::optional H1,\n boost::optional H2) const {\n if (!H1 && !H2)\n return transform_to(point).norm();\n Point3 d = transform_to(point, H1, H2);\n double x = d.x(), y = d.y(), z = d.z(), d2 = x * x + y * y + z * z, n = sqrt(\n d2);\n Matrix D_result_d = (Matrix(1, 3) << x / n, y / n, z / n);\n if (H1)\n *H1 = D_result_d * (*H1);\n if (H2)\n *H2 = D_result_d * (*H2);\n return n;\n}\n\n/* ************************************************************************* */\ndouble Pose3::range(const Pose3& point, boost::optional H1,\n boost::optional H2) const {\n double r = range(point.translation(), H1, H2);\n if (H2) {\n Matrix H2_ = *H2 * point.rotation().matrix();\n *H2 = zeros(1, 6);\n insertSub(*H2, H2_, 0, 3);\n }\n return r;\n}\n\n/* ************************************************************************* */\nboost::optional align(const vector& pairs) {\n const size_t n = pairs.size();\n if (n < 3)\n return boost::none; // we need at least three pairs\n\n // calculate centroids\n Vector cp = zero(3), cq = zero(3);\n BOOST_FOREACH(const Point3Pair& pair, pairs){\n cp += pair.first.vector();\n cq += pair.second.vector();\n}\n double f = 1.0 / n;\n cp *= f;\n cq *= f;\n\n // Add to form H matrix\n Matrix H = zeros(3, 3);\n BOOST_FOREACH(const Point3Pair& pair, pairs){\n Vector dp = pair.first.vector() - cp;\n Vector dq = pair.second.vector() - cq;\n H += dp * dq.transpose();\n}\n\n// Compute SVD\n Matrix U, V;\n Vector S;\n svd(H, U, S, V);\n\n // Recover transform with correction from Eggert97machinevisionandapplications\n Matrix UVtranspose = U * V.transpose();\n Matrix detWeighting = eye(3, 3);\n detWeighting(2, 2) = UVtranspose.determinant();\n Rot3 R(Matrix(V * detWeighting * U.transpose()));\n Point3 t = Point3(cq) - R * Point3(cp);\n return Pose3(R, t);\n}\n\n/* ************************************************************************* */\nstd::ostream &operator<<(std::ostream &os, const Pose3& pose) {\n os << pose.rotation() << \"\\n\" << pose.translation() << endl;\n return os;\n}\n\n} // namespace gtsam\n", "meta": {"hexsha": "bfd2fcb9aed98a9b673d8911a898399d8502cb4f", "size": 11512, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "gtsam/geometry/Pose3.cpp", "max_stars_repo_name": "ashariati/gtsam-3.2.1", "max_stars_repo_head_hexsha": "f880365c259eb7532b9c1d20979ecad2eb04779c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8.0, "max_stars_repo_stars_event_min_datetime": "2017-05-10T08:07:42.000Z", "max_stars_repo_stars_event_max_datetime": "2019-09-26T19:11:18.000Z", "max_issues_repo_path": "gtsam/geometry/Pose3.cpp", "max_issues_repo_name": "ashariati/gtsam-3.2.1", "max_issues_repo_head_hexsha": "f880365c259eb7532b9c1d20979ecad2eb04779c", "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": "gtsam/geometry/Pose3.cpp", "max_forks_repo_name": "ashariati/gtsam-3.2.1", "max_forks_repo_head_hexsha": "f880365c259eb7532b9c1d20979ecad2eb04779c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 6.0, "max_forks_repo_forks_event_min_datetime": "2017-02-17T18:55:24.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-25T00:28:40.000Z", "avg_line_length": 30.7807486631, "max_line_length": 89, "alphanum_fraction": 0.5044301598, "num_tokens": 3215, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7371581510799252, "lm_q2_score": 0.6757645944891558, "lm_q1q2_score": 0.49814537903890155}} {"text": "//\n// Copyright 2016 Pixar\n//\n// Licensed under the Apache License, Version 2.0 (the \"Apache License\")\n// with the following modification; you may not use this file except in\n// compliance with the Apache License and the following modification to it:\n// Section 6. Trademarks. is deleted and replaced with:\n//\n// 6. Trademarks. This License does not grant permission to use the trade\n// names, trademarks, service marks, or product names of the Licensor\n// and its affiliates, except as required to comply with Section 4(c) of\n// the License and to reproduce the content of the NOTICE file.\n//\n// You may obtain a copy of the Apache 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 Apache License with the above modification is\n// distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied. See the Apache License for the specific\n// language governing permissions and limitations under the Apache License.\n//\n#include \n\n#include \"pxr/pxr.h\"\n#include \"pxr/base/gf/homogeneous.h\"\n\nusing namespace boost::python;\n\nPXR_NAMESPACE_USING_DIRECTIVE\n\nvoid wrapHomogeneous()\n{ \n def(\"GetHomogenized\", (GfVec4d (*)(const GfVec4d &)) GfGetHomogenized);\n def(\"GetHomogenized\", (GfVec4f (*)(const GfVec4f &)) GfGetHomogenized);\n\n def(\"HomogeneousCross\", (GfVec4d (*)(const GfVec4d &, const GfVec4d &)) GfHomogeneousCross);\n def(\"HomogeneousCross\", (GfVec4f (*)(const GfVec4f &, const GfVec4f &)) GfHomogeneousCross);\n\n def(\"Project\", (GfVec3d (*)(const GfVec4d &)) GfProject);\n def(\"Project\", (GfVec3f (*)(const GfVec4f &)) GfProject);\n}\n", "meta": {"hexsha": "fd70318aa842d7c0834a4bb72315642f757923a2", "size": 1740, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "pxr/base/gf/wrapHomogeneous.cpp", "max_stars_repo_name": "DougRogers-DigitalFish/USD", "max_stars_repo_head_hexsha": "d8a405a1344480f859f025c4f97085143efacb53", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 3680.0, "max_stars_repo_stars_event_min_datetime": "2016-07-26T18:28:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T09:55:05.000Z", "max_issues_repo_path": "pxr/base/gf/wrapHomogeneous.cpp", "max_issues_repo_name": "DougRogers-DigitalFish/USD", "max_issues_repo_head_hexsha": "d8a405a1344480f859f025c4f97085143efacb53", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 1759.0, "max_issues_repo_issues_event_min_datetime": "2016-07-26T19:19:59.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T21:24:00.000Z", "max_forks_repo_path": "pxr/base/gf/wrapHomogeneous.cpp", "max_forks_repo_name": "DougRogers-DigitalFish/USD", "max_forks_repo_head_hexsha": "d8a405a1344480f859f025c4f97085143efacb53", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 904.0, "max_forks_repo_forks_event_min_datetime": "2016-07-26T18:33:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T09:55:16.000Z", "avg_line_length": 39.5454545455, "max_line_length": 96, "alphanum_fraction": 0.7270114943, "num_tokens": 467, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7090191337850932, "lm_q2_score": 0.7025300573952052, "lm_q1q2_score": 0.4981072527523402}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include // check the memory usage\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n\n#include \"../src/CZZ.h\"\n#include \"../src/Params.h\"\n#include \"../src/PubKey.h\"\n#include \"../src/Scheme.h\"\n#include \"../src/SchemeAlgo.h\"\n#include \"../src/SecKey.h\"\n#include \"../src/TestScheme.h\"\n#include \"../src/TimeUtils.h\"\n#include \"../src/Ring2Utils.h\"\n#include \"../src/StringUtils.h\"\n#include \"../src/EvaluatorUtils.h\"\n\n#include \"Database.h\"\n#include \"LRtest.h\"\n#include \"HELR.h\"\n\n\nusing namespace NTL;\nusing namespace std;\n\n\n\nint main(int Argc, char** Argv) {\n\n \n if(Argc != 3){\n cout << \"-------------------------------------------------------------\" << endl;\n cerr << \"Enter the File and degree of approximation \\t\" << \"(e.g. $test edin.txt 3) \\n \";\n }\n \n char* filename = Argv[1];\n int polydeg = atoi(Argv[2]); // degree of approximation polynomial\n \n \n dMat zData;\n dMat* zTest = new dMat[5];\n dMat* zTrain = new dMat[5];\n \n \n int nLine= readData(zData, filename);\n \n cout << \"Sample the learning and test data ...\" << endl;\n cvRandomSamplingData(zTrain, zTest, zData, filename);\n\n \n //----------------------------------------------------------------\n // Parameters for Logistic regression\n //----------------------------------------------------------------\n\n long logN= 17;\n long logp= 28;\n long logl= 10;\n long logq, cBit1, cBit2;\n int max_iter;\n \n struct LRpar LRparams;\n ReadLRparams(LRparams, max_iter, zTrain[0], polydeg, logp);\n \n SetNumThreads(LRparams.dim1);\n //SetNumThreads(4);\n \n switch(polydeg){\n case 3:\n cBit1= (LRparams.logn - LRparams.log2polyscale); // 1st iteration\n cBit2 = (3*logp+ LRparams. logn - LRparams.log2polyscale); // 2nd~ iteration\n logq = cBit1 + (LRparams.max_iter-1)*(cBit2)+ logp + logl; // max-bitlength we need\n break;\n \n case 7:\n cBit1= (LRparams.logn - LRparams.log2polyscale); // 1st iteration\n cBit2= (4*logp+ LRparams.logn - LRparams.log2polyscale);\n logq= cBit1 + (LRparams.max_iter-1)*(cBit2)+ logp + logl;\n break;\n }\n \n \n \n \n cout << \"Data dimension with dummy vectors: \" << LRparams.dim1 << \", Number of lines: \" << nLine << endl;\n \n cout << \"-------------------------------------------------------------\" << endl;\n cout << \"Key Generation ... (logN,logp,logq, nslots)= (\" ;\n cout << logN << \",\" << logp << \",\" << logq << \",\" << LRparams.nslots << \")\" < (diff).count()/1000.0 << \" s\" << endl;\n\n \n\n \n LogReg LR(scheme, secretKey, LRparams);\n dMat HEtheta_list;\n \n ofstream fout;\n fout.open(\"beta.txt\");\n\n \n for(int k = 0; k < 1; ++k){\n \n cout << \"-------------------------------------------------------------\" << endl;\n cout << k << \"th Data Encryption ... \" << endl;\n \n struct rusage usage;\n \n start= chrono::steady_clock::now();\n \n Cipher* zTrainCipher = new Cipher[LRparams.dim1];\n \n LR.EncryptData(zTrainCipher, zTrain[k]);\n \n end = std::chrono::steady_clock::now();\n diff = end - start;\n cout << \"Enc time= \" << chrono::duration (diff).count()/1000.0 << \"(s), \" ;\n \n int ret = getrusage(RUSAGE_SELF,&usage);\n cout<< \"Mem: \" << usage.ru_maxrss/(1024) << \"(MB)\" << endl;\n \n \n cout << \"-------------------------------------------------------------\" << endl;\n cout << \"HE Logistic Regression ... \" << endl;\n \n Cipher* thetaCipher= new Cipher[LRparams.dim1];\n \n start= chrono::steady_clock::now();\n \n LR.HElogreg(thetaCipher, zTrainCipher, zTrain[k]);\n \n \n end = std::chrono::steady_clock::now();\n diff = end - start;\n cout << \"Eval time= \" << chrono::duration (diff).count()/1000.0 << \"(s), \" ;\n \n ret = getrusage(RUSAGE_SELF,&usage);\n cout<< \"Mem: \" << usage.ru_maxrss/(1024) << \"(MB)\" << endl;\n \n \n cout << \"-------------------------------------------------------------\" << endl;\n cout << \"Decryption ... \" << endl;\n \n dVec HEtheta(LRparams.dim1, 0.0);\n\n CZZ* dtheta = new CZZ[LRparams.dim1];\n \n for(int i=0; i< LRparams.dim1; ++i){\n dtheta[i] = (scheme.decrypt(secretKey, thetaCipher[i]))[0];\n \n conv(HEtheta[i], dtheta[i].r);\n HEtheta[i] = scaledown(HEtheta[i], LRparams.logp);\n cout << \"[\" << HEtheta[i] << \"] \" ;\n }\n cout << \": enc \" << endl;\n \n getAUC(HEtheta, zTest[k]);\n HEtheta_list.push_back(HEtheta);\n \n \n cout << \"-------------------------------------------------------------\" << endl;\n cout << \"Compare with unenc LR \" << endl;\n dVec mtheta(LRparams.dim1, 0.0);\n \n for(int i= 0; i< LRparams.max_iter; i++){\n LR_poly(mtheta, zTrain[k], LRparams);\n }\n \n for(int i= 0; i< LRparams.dim1; i++)\n cout << \"[\" << mtheta[i] << \"] \" ;\n cout << \": unenc \" << endl;\n \n getAUC(mtheta, zTest[k]);\n \n cout << \"MSE (HELR/non-HELR): \" << getMSE(HEtheta, mtheta) << endl;\n \n \n cout << \"-------------------------------------------------------------\" << endl;\n cout << \"Compare with sigmoid LR \" << endl;\n dVec mtheta_sig(LRparams.dim1, 0.0);\n \n for(int i= 0; i< LRparams.max_iter; i++){\n LR_sigmoid(mtheta_sig, zTrain[k], LRparams);\n }\n \n for(int i= 0; i< LRparams.dim1; i++)\n cout << \"[\" << mtheta_sig[i] << \"] \" ;\n cout << \": unenc \" << endl;\n \n getAUC(mtheta_sig, zTest[k]);\n \n cout << \"MSE (HELR/non-HELR): \" << getMSE(HEtheta, mtheta_sig) << endl;\n\n }\n \n \n //! write the beta results in the text file\n fout << \"-------------------------------------------------------------\" << endl;\n fout << \"[\" << endl;\n for(int i = 0; i < LRparams.dim1; ++i){\n for(int k = 0; k < 4; ++k){\n fout << HEtheta_list[k][i] << \",\" ;\n }\n fout << HEtheta_list[4][i] << \";\" << endl;\n }\n fout << \"];\" << endl;\n fout.close();\n \n \n \n delete[] zTest;\n delete[] zTrain;\n\n return 0;\n}\n\n\n\n\n\n\n", "meta": {"hexsha": "ee6ac088bbb0fcbc9ef20fd68682a2262fc6b81b", "size": 7190, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Test_HELR.cpp", "max_stars_repo_name": "K-miran/HELR", "max_stars_repo_head_hexsha": "c94951f2691d55defc82f95d3144c831eb6c8796", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 31.0, "max_stars_repo_stars_event_min_datetime": "2018-01-20T13:31:10.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T02:56:15.000Z", "max_issues_repo_path": "Test_HELR.cpp", "max_issues_repo_name": "yuejiayang/HELR", "max_issues_repo_head_hexsha": "5bc8ee66430e1e9a4f933a700260008ce35cb118", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-01-25T02:54:53.000Z", "max_issues_repo_issues_event_max_datetime": "2018-02-09T10:48:39.000Z", "max_forks_repo_path": "Test_HELR.cpp", "max_forks_repo_name": "yuejiayang/HELR", "max_forks_repo_head_hexsha": "5bc8ee66430e1e9a4f933a700260008ce35cb118", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 12.0, "max_forks_repo_forks_event_min_datetime": "2018-01-20T13:31:14.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-28T02:20:39.000Z", "avg_line_length": 29.1093117409, "max_line_length": 112, "alphanum_fraction": 0.4696801113, "num_tokens": 1887, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772286044095, "lm_q2_score": 0.5698526514141571, "lm_q1q2_score": 0.4980952262609611}} {"text": "#include \n\n#include \n#include \n#include \n\n#include \n\n#include \"ProcessMain.hpp\"\n#include \"../export_tree/TreeExportHook.hpp\"\n\nusing namespace boost::numeric;\n\ntemplate\nublas::vector cross( const ublas::vector &a, const ublas::vector &b )\n{\n\tBOOST_ASSERT(a.size() == 3);\n\tBOOST_ASSERT(b.size() == 3);\n\n\tublas::vector\tresult(3);\n\tresult(0) = a(1) * b(2) - a(2) * b(1);\n\tresult(1) = a(2) * b(0) - a(0) * b(2);\n\tresult(2) = a(0) * b(1) - a(1) * b(0);\n\treturn result;\n}\n\nenum cham_group_t {prop_2nd, drift_left, drift_right};\n\ndouble Psi_L = 1.0447;\ndouble Psi_R = -1.0209;\n\ntemplate\ntrack3d_t make_track( int event_id, TrackGroup &tg_X, TrackGroup &tg_Y )\n{\n\tstatic ublas::matrix m1(3, 3), m2(3, 3), A(3, 3);\n\n\tm1(0, 0) = 1; m1(1, 0) = 0; m1(2, 0) = 0;\n\tm1(0, 1) = 0; m1(1, 1) = 0; m1(2, 1) = 1;\n\tm1(0, 2) = 0; m1(1, 2) = -1; m1(2, 2) = 0;\n\n\tdouble Psi;\n\tif (cham_group == cham_group_t::drift_left)\n\t{\n\t\tPsi = Psi_L;\n\t}\n\telse if (cham_group == cham_group_t::drift_right)\n\t{\n\t\tPsi = Psi_R;\n\t}\n\telse if (cham_group == cham_group_t::prop_2nd)\n\t{\n\t\tPsi = 0;\n\t}\n\telse\n\t{\n\t\tthrow;\n\t}\n\n\tm2(0, 0) = cos(Psi); m2(1, 0) = 0; m2(2, 0) = -sin(Psi);\n\tm2(0, 1) = 0; m2(1, 1) = 1; m2(2, 1) = 0;\n\tm2(0, 2) = sin(Psi); m2(1, 2) = 0; m2(2, 2) = cos(Psi);\n\n\tA = ublas::prod(m1, m2);\n\n\tublas::vector o(3), a(3), b(3);\n\n\tif (cham_group == cham_group_t::drift_left)\n\t{\n\t\to(0) = 165.2;\n\t\to(1) = 512.4;\n\t\to(2) = 0.3;\n\t}\n\telse if (cham_group == cham_group_t::drift_right)\n\t{\n\t\to(0) = 159.7;\n\t\to(1) = -524.0;\n\t\to(2) = -2.8;\n\t}\n\telse if (cham_group == cham_group_t::prop_2nd)\n\t{\n\t\to(0) = -1486.0;\n\t\to(1) = 0;\n\t\to(2) = 2;\n\t}\n\telse\n\t{\n\t\tthrow;\n\t}\n\n\tb(0) = 1;\n\tb(1) = tg_Y.c1[0];\n\tb(2) = tg_X.c1[0];\n\tb = ublas::prod(A, b);\n\n\tublas::unit_vector xk(3, 1);\n\tublas::unit_vector xl(3, 2);\n\ta = o + ublas::prod(A, xk) * tg_Y.c0[0] + ublas::prod(A, xl) * tg_X.c0[0];\n\n\treturn track3d_t({a, b});\n}\n\nvoid\tfind_intersection_points(\n\tconst track3d_t &t1, const track3d_t &t2,\n\tintersection_t *i1, intersection_t *i2\n\t)\n{\n\tauto cr = cross(t1.b, t2.b);\n\tdouble cr_norm = norm_2(cr);\n\n\t// Following code solves linear system\n\t// (t1.b, t2.b, cr) * x = t1.a - t2.a\n\tublas::matrix\tB(3, 3);\n\tublas::vector\tx;\n\tublas::permutation_matrix<>\tpm(B.size1());\n\n\tfor(unsigned int row = 0; row < B.size1(); row++)\n\t{\n\t\tB(row, 0) = t1.b(row);\n\t\tB(row, 1) = t2.b(row);\n\t\tB(row, 2) = cr(row);\n\t}\n\tx = t1.a - t2.a; // put RHS into x\n\n\tint\tsingular = ublas::lu_factorize(B, pm);\n\tif(singular)\n\t{\n\t\tthrow \"lu_factorize()==0\";\n\t}\n\n\tublas::lu_substitute(B, pm, x);\n\n\tx(2) -= ublas::inner_prod(cr, t1.a - t2.a) / cr_norm;\n\tublas::vector\tiv1 = t1.a - x(0) * t1.b;\n\tublas::vector\tiv2 = t2.a + x(1) * t2.b;\n\n\ti1->x = iv1(0); i1->y = iv1(1); i1->z = iv1(2);\n\ti2->x = iv2(0); i2->y = iv2(1); i2->z = iv2(2);\n}\n\ndouble\tcalc_theta(track3d_t track)\n{\n\tdouble\tcos_theta =\n\t ublas::inner_prod(track.b, ublas::unit_vector(3, 0))\n\t / norm_2(track.b);\n\treturn acos(cos_theta);\n}\n\ndouble\tcalc_phi(track3d_t track)\n{\n\treturn atan2(\n\t\tublas::inner_prod(track.b, ublas::unit_vector(3, 1)),\n\t\tublas::inner_prod(track.b, ublas::unit_vector(3, 2))\n\t\t);\n}\n\ndouble\tcalc_incident_momentum(double beam_momentum, intersection_t &i1, intersection_t &i2)\n{\n\tconst double\tTARGET_START = -130; // mm\n\tdouble\tz = (i1.x + i2.x) / 2 - TARGET_START; // mm\n\tconst double\tdE_over_dx = 4; // MeV g^-1 cm^2\n\tconst double\tlih2_density = 0.0708; // g cm^-3\n\n\treturn beam_momentum - dE_over_dx * lih2_density * (z/10);\n}\n\nvoid\tTTree_UnfriendAll(TTree *tree)\n{\n\tTList *friends = tree->GetListOfFriends();\n\n\twhile(friends->GetSize() != 0)\n\t{\n\t\tfriends->RemoveLast();\n\t}\n}\n\nTTree*\tProcess( TTree *events, TTree *cycle_efficiency, Geometry &geom, double central_momentum, intersection_set_t *s )\n{\n\tTTree\t*events_new;\n\tuint32_t\tevent_cause, timestamp;\n\tdouble\ttheta_l, theta_r, phi_l, phi_r;\n\tdouble\tbeam_momentum, incident_momentum_l, incident_momentum_r;\n\tTrackGroup\ttg_F1X, tg_F1Y, tg_F2X, tg_F2Y, tg_LX, tg_LY, tg_RX, tg_RY;\n\tconst double\tF1_length = geom.normal_pos[1][DEV_AXIS_X].back();\n\n\tevents->GetBranch(\"event_cause\")->SetAddress(&event_cause);\n\tevents->GetBranch(\"timestamp\")->SetAddress(×tamp);\n\tevents->GetBranch(\"t1X_track_count\")->SetAddress(&tg_F1X.track_count);\n\tevents->GetBranch(\"t1Y_track_count\")->SetAddress(&tg_F1Y.track_count);\n\tevents->GetBranch(\"t2X_track_count\")->SetAddress(&tg_F2X.track_count);\n\tevents->GetBranch(\"t2Y_track_count\")->SetAddress(&tg_F2Y.track_count);\n\tevents->GetBranch(\"t3X_track_count\")->SetAddress(&tg_LX.track_count);\n\tevents->GetBranch(\"t3Y_track_count\")->SetAddress(&tg_LY.track_count);\n\tevents->GetBranch(\"t4X_track_count\")->SetAddress(&tg_RX.track_count);\n\tevents->GetBranch(\"t4Y_track_count\")->SetAddress(&tg_RY.track_count);\n\n\tevents->SetBranchAddress(\"t1X_c0\", &tg_F1X.c0_ptr);\n\tevents->SetBranchAddress(\"t1X_c1\", &tg_F1X.c1_ptr);\n\tevents->SetBranchAddress(\"t1X_hits_count\", &tg_F1X.hits_count_ptr);\n\tevents->SetBranchAddress(\"t1Y_c0\", &tg_F1Y.c0_ptr);\n\tevents->SetBranchAddress(\"t1Y_c1\", &tg_F1Y.c1_ptr);\n\tevents->SetBranchAddress(\"t1Y_hits_count\", &tg_F1Y.hits_count_ptr);\n\n\tevents->SetBranchAddress(\"t2X_c0\", &tg_F2X.c0_ptr);\n\tevents->SetBranchAddress(\"t2X_c1\", &tg_F2X.c1_ptr);\n\tevents->SetBranchAddress(\"t2X_hits_count\", &tg_F2X.hits_count_ptr);\n\tevents->SetBranchAddress(\"t2Y_c0\", &tg_F2Y.c0_ptr);\n\tevents->SetBranchAddress(\"t2Y_c1\", &tg_F2Y.c1_ptr);\n\tevents->SetBranchAddress(\"t2Y_hits_count\", &tg_F2Y.hits_count_ptr);\n\n\tevents->SetBranchAddress(\"t3X_c0\", &tg_LX.c0_ptr);\n\tevents->SetBranchAddress(\"t3X_c1\", &tg_LX.c1_ptr);\n\tevents->SetBranchAddress(\"t3X_hits_count\", &tg_LX.hits_count_ptr);\n\tevents->SetBranchAddress(\"t3Y_c0\", &tg_LY.c0_ptr);\n\tevents->SetBranchAddress(\"t3Y_c1\", &tg_LY.c1_ptr);\n\tevents->SetBranchAddress(\"t3Y_hits_count\", &tg_LY.hits_count_ptr);\n\n\tevents->SetBranchAddress(\"t4X_c0\", &tg_RX.c0_ptr);\n\tevents->SetBranchAddress(\"t4X_c1\", &tg_RX.c1_ptr);\n\tevents->SetBranchAddress(\"t4X_hits_count\", &tg_RX.hits_count_ptr);\n\tevents->SetBranchAddress(\"t4Y_c0\", &tg_RY.c0_ptr);\n\tevents->SetBranchAddress(\"t4Y_c1\", &tg_RY.c1_ptr);\n\tevents->SetBranchAddress(\"t4Y_hits_count\", &tg_RY.hits_count_ptr);\n\n\t// select branches to work with\n\tevents->SetBranchStatus(\"*\", 0);\n\tevents->SetBranchStatus(\"event_cause\", 1);\n\tevents->SetBranchStatus(\"timestamp\", 1);\n\tevents->SetBranchStatus(\"*_track_count\", 1);\n\tevents->SetBranchStatus(\"*_hits_count\", 1);\n\tevents->SetBranchStatus(\"*_used_chambers_mask\", 1);\n\tevents->SetBranchStatus(\"*_c0\", 1);\n\tevents->SetBranchStatus(\"*_c1\", 1);\n\t// clone tree headers\n\t// this also copies branches addresses\n\tevents_new = events->CloneTree(0);\n\tTTree_UnfriendAll(events_new);\n\n\tdouble min_cycle_efficiency;\n\tcycle_efficiency->SetBranchStatus(\"min_cycle_efficiency\", 1);\n\tcycle_efficiency->SetBranchAddress(\"min_cycle_efficiency\", &min_cycle_efficiency);\n\tevents_new->Branch(\"min_cycle_efficiency\", &min_cycle_efficiency, \"min_cycle_efficiency/D\");\n\n\ts->br_lr = events_new->Branch(\"LR\", &s->i_lr, \"LR_x/D:LR_y/D:LR_z/D\");\n\ts->br_rl = events_new->Branch(\"RL\", &s->i_rl, \"RL_x/D:RL_y/D:RL_z/D\");\n\ts->br_f2r = events_new->Branch(\"F2R\", &s->i_f2r, \"F2R_x/D:F2R_y/D:F2R_z/D\");\n\ts->br_f2l = events_new->Branch(\"F2L\", &s->i_f2l, \"F2L_x/D:F2L_y/D:F2L_z/D\");\n\ts->br_rf2 = events_new->Branch(\"RF2\", &s->i_rf2, \"RF2_x/D:RF2_y/D:RF2_z/D\");\n\ts->br_lf2 = events_new->Branch(\"LF2\", &s->i_lf2, \"LF2_x/D:LF2_y/D:LF2_z/D\");\n\n\tevents_new->Branch(\"theta_l\", &theta_l, \"theta_l/D\");\n\tevents_new->Branch(\"theta_r\", &theta_r, \"theta_r/D\");\n\tevents_new->Branch(\"phi_l\", &phi_l, \"phi_l/D\");\n\tevents_new->Branch(\"phi_r\", &phi_r, \"phi_r/D\");\n\tevents_new->Branch(\"beam_momentum\", &beam_momentum, \"beam_momentum/D\");\n\tevents_new->Branch(\"incident_momentum_l\", &incident_momentum_l, \"incident_momentum_l/D\");\n\tevents_new->Branch(\"incident_momentum_r\", &incident_momentum_r, \"incident_momentum_r/D\");\n\n\tfor(int i = 0; i < events->GetEntries(); i++)\n\t{\n\t\ttrack3d_t\tt_L, t_R, t_F2;\n\t\tevents->GetEntry(i);\n\t\tcycle_efficiency->GetEntry(i);\n\n\t\tbool\tleft_arm = (tg_LX.track_count == 1) && (tg_LY.track_count == 1);\n\t\tbool\tright_arm = (tg_RX.track_count == 1) && (tg_RY.track_count == 1);\n\t\tbool\tincident =\n\t\t (tg_F1X.track_count == 1) && (tg_F1Y.track_count == 1) &&\n\t\t (tg_F2X.track_count == 1) && (tg_F2Y.track_count == 1);\n\n\t\tif (!incident)\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\n\t\tt_F2 = make_track(i, tg_F2X, tg_F2Y);\n\n\t\tdouble\tF1_x = tg_F1X.c0[0] + F1_length * tg_F1X.c1[0];\n\t\tconst double\tDISPERSION = (1.0 / 55) * 0.01; // 55 mm/%\n\t\tbeam_momentum = (1 + F1_x * DISPERSION) * central_momentum;\n\n\t\tif (left_arm)\n\t\t{\n\t\t\tt_L = make_track(i, tg_LX, tg_LY);\n\t\t\ttheta_l = calc_theta(t_L);\n\t\t\tphi_l = calc_phi(t_L);\n\t\t\tfind_intersection_points(t_F2, t_L, &s->i_f2l, &s->i_lf2);\n\t\t\tincident_momentum_l = calc_incident_momentum(beam_momentum, s->i_f2l, s->i_lf2);\n\t\t}\n\t\telse\n\t\t{\n\t\t\ttheta_l = NAN;\n\t\t\tphi_l = NAN;\n\t\t\ts->i_f2l.x = NAN; s->i_f2l.y = NAN; s->i_f2l.z = NAN;\n\t\t\ts->i_lf2.x = NAN; s->i_lf2.y = NAN; s->i_lf2.z = NAN;\n\t\t\tincident_momentum_l = NAN;\n\t\t}\n\t\tif (right_arm)\n\t\t{\n\t\t\tt_R = make_track(i, tg_RX, tg_RY);\n\t\t\ttheta_r = calc_theta(t_R);\n\t\t\tphi_r = calc_phi(t_R);\n\t\t\tfind_intersection_points(t_F2, t_R, &s->i_f2r, &s->i_rf2);\n\t\t\tincident_momentum_r = calc_incident_momentum(beam_momentum, s->i_f2r, s->i_rf2);\n\t\t}\n\t\telse\n\t\t{\n\t\t\ttheta_r = NAN;\n\t\t\tphi_r = NAN;\n\t\t\ts->i_f2r.x = NAN; s->i_f2r.y = NAN; s->i_f2r.z = NAN;\n\t\t\ts->i_rf2.x = NAN; s->i_rf2.y = NAN; s->i_rf2.z = NAN;\n\t\t\tincident_momentum_r = NAN;\n\t\t}\n\n\t\tif (left_arm && right_arm)\n\t\t{\n\t\t\tfind_intersection_points(t_L, t_R, &s->i_lr, &s->i_rl);\n\t\t}\n\t\telse\n\t\t{\n\t\t\ts->i_lr.x = NAN; s->i_lr.y = NAN; s->i_lr.z = NAN;\n\t\t\ts->i_rl.x = NAN; s->i_rl.y = NAN; s->i_rl.z = NAN;\n\t\t}\n\n\t\tevents_new->Fill();\n\t}\n\n\treturn events_new;\n}\n", "meta": {"hexsha": "63471b8ed7133465aa994db881cd8ec66f25555f", "size": 9967, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/utils/process/ProcessMain.cpp", "max_stars_repo_name": "veprbl/libepecur", "max_stars_repo_head_hexsha": "83167ac6220e69887c03b556f1a7ffc518cbb227", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-25T13:41:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-25T13:41:19.000Z", "max_issues_repo_path": "src/utils/process/ProcessMain.cpp", "max_issues_repo_name": "veprbl/libepecur", "max_issues_repo_head_hexsha": "83167ac6220e69887c03b556f1a7ffc518cbb227", "max_issues_repo_licenses": ["Unlicense"], "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/utils/process/ProcessMain.cpp", "max_forks_repo_name": "veprbl/libepecur", "max_forks_repo_head_hexsha": "83167ac6220e69887c03b556f1a7ffc518cbb227", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.2948328267, "max_line_length": 120, "alphanum_fraction": 0.6700110364, "num_tokens": 3713, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026641072386, "lm_q2_score": 0.5428632831725052, "lm_q1q2_score": 0.49796993590014127}} {"text": "/* Copyright (c) 2010-2019, Delft University of Technology\n * All rigths reserved\n *\n * This file is part of the Tudat. Redistribution and use in source and\n * binary forms, with or without modification, are permitted exclusively\n * under the terms of the Modified BSD license. You should have received\n * a copy of the license with this file. If not, please or visit:\n * http://tudat.tudelft.nl/LICENSE.\n *\n */\n\n#include \n\n#include \n\n#include \"tudat/math/basic/sphericalHarmonics.h\"\n#include \"tudat/math/basic/basicMathematicsFunctions.h\"\n\nnamespace tudat\n{\nnamespace basic_mathematics\n{\n\n//! Update maximum degree and order of cache\nvoid SphericalHarmonicsCache::resetMaximumDegreeAndOrder( const int maximumDegree, const int maximumOrder )\n{\n maximumDegree_ = maximumDegree;\n maximumOrder_ = maximumOrder;\n\n if( maximumOrder_ > maximumDegree_ )\n {\n maximumOrder_ = maximumDegree_;\n }\n legendreCache_->resetMaximumDegreeAndOrder( maximumDegree_, maximumOrder_ );\n\n sinesOfLongitude_.resize( maximumOrder_ + 1 );\n cosinesOfLongitude_.resize( maximumOrder_ + 1 );\n referenceRadiusRatioPowers_.resize( maximumDegree_ + 2 );\n}\n\n\n//! Compute the gradient of a single term of a spherical harmonics potential field.\nEigen::Vector3d computePotentialGradient(\n const double distance,\n const double radiusPowerTerm,\n const double cosineOfOrderLongitude,\n const double sineOfOrderLongitude,\n const double cosineOfLatitude,\n const double preMultiplier,\n const int degree,\n const int order,\n const double cosineHarmonicCoefficient,\n const double sineHarmonicCoefficient,\n const double legendrePolynomial,\n const double legendrePolynomialDerivative )\n{\n // Return result.\n return ( Eigen::Vector3d( ) <<\n - preMultiplier / distance\n * radiusPowerTerm\n * ( static_cast< double >( degree ) + 1.0 ) * legendrePolynomial\n * ( cosineHarmonicCoefficient * cosineOfOrderLongitude\n + sineHarmonicCoefficient * sineOfOrderLongitude ),\n preMultiplier * radiusPowerTerm\n * legendrePolynomialDerivative * cosineOfLatitude * (\n cosineHarmonicCoefficient * cosineOfOrderLongitude\n + sineHarmonicCoefficient * sineOfOrderLongitude ),\n preMultiplier * radiusPowerTerm\n * static_cast< double >( order ) * legendrePolynomial\n * ( sineHarmonicCoefficient * cosineOfOrderLongitude\n - cosineHarmonicCoefficient * sineOfOrderLongitude ) ).finished( );\n}\n\n//! Compute the gradient of a single term of a spherical harmonics potential field.\nEigen::Vector3d computePotentialGradient(\n const Eigen::Vector3d& sphericalPosition,\n const double referenceRadius,\n const double preMultiplier,\n const int degree,\n const int order,\n const double cosineHarmonicCoefficient,\n const double sineHarmonicCoefficient,\n const double legendrePolynomial,\n const double legendrePolynomialDerivative )\n{\n return computePotentialGradient(\n sphericalPosition( radiusIndex ),\n basic_mathematics::raiseToIntegerPower\n ( referenceRadius / sphericalPosition( radiusIndex ), static_cast< double >( degree ) + 1.0 ),\n std::cos( static_cast< double >( order ) * sphericalPosition( longitudeIndex ) ),\n std::sin( static_cast< double >( order ) * sphericalPosition( longitudeIndex ) ),\n std::cos( sphericalPosition( latitudeIndex ) ), preMultiplier, degree, order,\n cosineHarmonicCoefficient, sineHarmonicCoefficient, legendrePolynomial,legendrePolynomialDerivative );\n}\n\n//! Compute the gradient of a single term of a spherical harmonics potential field.\nEigen::Vector3d computePotentialGradient( const Eigen::Vector3d& sphericalPosition,\n const double preMultiplier,\n const int degree,\n const int order,\n const double cosineHarmonicCoefficient,\n const double sineHarmonicCoefficient,\n const double legendrePolynomial,\n const double legendrePolynomialDerivative,\n const std::shared_ptr< SphericalHarmonicsCache > sphericalHarmonicsCache )\n{\n return computePotentialGradient(\n sphericalPosition( radiusIndex ),\n sphericalHarmonicsCache->getReferenceRadiusRatioPowers( degree + 1 ),\n sphericalHarmonicsCache->getCosineOfMultipleLongitude( order ),\n sphericalHarmonicsCache->getSineOfMultipleLongitude( order ),\n sphericalHarmonicsCache->getLegendreCache( )->getCurrentPolynomialParameterComplement( ),\n preMultiplier, degree, order,\n cosineHarmonicCoefficient, sineHarmonicCoefficient, legendrePolynomial,legendrePolynomialDerivative );\n}\n\n} // namespace basic_mathematics\n} // namespace tudat\n", "meta": {"hexsha": "246ecbc0c2be172f5f11b2eb0531a54a1025613d", "size": 5269, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/math/basic/sphericalHarmonics.cpp", "max_stars_repo_name": "kimonito98/tudat", "max_stars_repo_head_hexsha": "c28f2a3e78b8492e2e054ad5e0d1f9ad785cd092", "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/math/basic/sphericalHarmonics.cpp", "max_issues_repo_name": "kimonito98/tudat", "max_issues_repo_head_hexsha": "c28f2a3e78b8492e2e054ad5e0d1f9ad785cd092", "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/math/basic/sphericalHarmonics.cpp", "max_forks_repo_name": "kimonito98/tudat", "max_forks_repo_head_hexsha": "c28f2a3e78b8492e2e054ad5e0d1f9ad785cd092", "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": 44.2773109244, "max_line_length": 118, "alphanum_fraction": 0.6612260391, "num_tokens": 1038, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026550642018, "lm_q2_score": 0.5428632831725052, "lm_q1q2_score": 0.49796993099100867}} {"text": "// 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 ITL_CGS_INCLUDE\n#define ITL_CGS_INCLUDE\n\n#include \n#include \n#include \n#include \n\n#include \n\nnamespace itl {\n\n/// Conjugate Gradient Squared\ntemplate < typename LinearOperator, typename Vector, \n\t typename Preconditioner, typename Iteration >\nint cgs(const LinearOperator &A, Vector &x, const Vector &b,\n\tconst Preconditioner &M, Iteration& iter)\n{\n mtl::vampir_trace<7007> tracer;\n typedef typename mtl::Collection::value_type Scalar;\n Scalar rho_1(0), rho_2(0), alpha(0), beta(0);\n Vector p(resource(x)), phat(resource(x)), q(resource(x)), qhat(resource(x)), vhat(resource(x)),\n\t u(resource(x)), uhat(resource(x)), r(b - A * x), rtilde= r;\n\n while (! iter.finished(r)) {\n\t++iter;\n\trho_1= dot(rtilde, r);\n\n\tif (rho_1 == 0.) iter.fail(2, \"cgs breakdown\");\n\n\tif (iter.first())\n\t p= u= r;\n\telse {\n\t beta = rho_1 / rho_2;\n\t u= r + beta * q;\n\t p= u + beta * (q + beta * p);\n\t}\n\n vhat= A * Vector(solve(M, p));\n\talpha = rho_1 / dot(rtilde, vhat);\n\tq= u - alpha * vhat;\n\n\tu+= q;\n\tuhat= solve(M, u);\n\t\n\tx+= alpha * uhat;\n\tqhat= A * uhat;\n\tr-= alpha * qhat;\n\n\trho_2= rho_1;\n }\n return iter;\n}\n\n/// Solver class for CGS method; right preconditioner ignored (prints warning if not identity)\n/** Methods inherited from \\ref base_solver. **/\ntemplate < typename LinearOperator, typename Preconditioner= pc::identity, \n\t typename RightPreconditioner= pc::identity >\nclass cgs_solver\n : public base_solver< cgs_solver, LinearOperator >\n{\n typedef base_solver< cgs_solver, LinearOperator > base;\n public:\n /// Construct solver from a linear operator; generate (left) preconditioner from it\n explicit cgs_solver(const LinearOperator& A) : base(A), L(A) \n {\n\tif (!pc::static_is_identity::value)\n\t std::cerr << \"Right Preconditioner ignored!\" << std::endl;\n }\n\n /// Construct solver from a linear operator and (left) preconditioner\n cgs_solver(const LinearOperator& A, const Preconditioner& L) : base(A), L(L) \n {\n\tif (!pc::static_is_identity::value)\n\t std::cerr << \"Right Preconditioner ignored!\" << std::endl;\n }\n\n /// Solve linear system approximately as specified by \\p iter\n template < typename HilbertSpaceX, typename HilbertSpaceB, typename Iteration >\n int solve(HilbertSpaceX& x, const HilbertSpaceB& b, Iteration& iter) const\n {\n\treturn cgs(this->A, x, b, L, iter);\n }\n\n private:\n Preconditioner L;\n};\n\n} // namespace itl\n\n#endif // ITL_CGS_INCLUDE\n\n\n\n", "meta": {"hexsha": "4fc55c57581dee7d5e804f67c0eb0c0b323f55dd", "size": 3303, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "boost/numeric/itl/krylov/cgs.hpp", "max_stars_repo_name": "lit-uriy/mtl4-mirror", "max_stars_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_stars_repo_licenses": ["MTLL"], "max_stars_count": 24.0, "max_stars_repo_stars_event_min_datetime": "2019-03-26T15:25:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T10:00:45.000Z", "max_issues_repo_path": "boost/numeric/itl/krylov/cgs.hpp", "max_issues_repo_name": "lit-uriy/mtl4-mirror", "max_issues_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_issues_repo_licenses": ["MTLL"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2020-04-17T12:35:32.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-03T15:46:25.000Z", "max_forks_repo_path": "boost/numeric/itl/krylov/cgs.hpp", "max_forks_repo_name": "lit-uriy/mtl4-mirror", "max_forks_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_forks_repo_licenses": ["MTLL"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2019-12-01T13:40:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-14T08:39:54.000Z", "avg_line_length": 30.8691588785, "max_line_length": 112, "alphanum_fraction": 0.6863457463, "num_tokens": 907, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998611746911, "lm_q2_score": 0.640635868562172, "lm_q1q2_score": 0.49796617169690394}} {"text": "#pragma once\n\n#include \"../geometry/LineSegment/LineSegment2/linesegment2.hh\"\n#include \n#include \n\nnamespace bold\n{\n class IncrementalRegression\n {\n public:\n IncrementalRegression()\n : d_xxSum{Eigen::Matrix2f::Zero()},\n d_xySum{Eigen::Vector2f::Zero()},\n d_nPoints{0},\n d_sqErrorSum{0.0f},\n d_dirty{false}\n {}\n \n void setSqError(float sqError)\n {\n d_sqErrorSum = sqError;\n }\n\n Eigen::Vector2f head() const\n {\n return d_head;\n }\n\n float getY(float x) const\n {\n return d_beta.dot(Eigen::Vector2f{x, 1});\n }\n\n float fit(Eigen::Vector2f const& point)\n {\n if (d_nPoints == 1)\n return (point - head()).norm();\n else if (d_xStart == d_xEnd)\n {\n return std::abs(point.x() - d_xStart);\n }\n else\n {\n solve();\n auto sigma = sigmaAt(point.x());\n auto yPred = getY(point.x());\n auto error = std::abs(yPred - point.y());\n return sigma == 0 ? error : error / sigma;\n }\n }\n\n float sigmaAt(float x)\n {\n auto _x = Eigen::Vector2f{x, 1};\n return sqrt(_x.transpose() * (1.0 / d_sqErrorSum * d_xxSum).inverse() * _x);\n }\n\n bool isVertical() const\n {\n return d_xStart == d_xEnd;\n }\n\n void addPoint(Eigen::Vector2f const& point)\n {\n d_points.push_back(point);\n\n auto x = Eigen::Vector2f{point.x(), 1};\n d_xxSum += x * x.transpose();\n d_xySum += x * point.y();\n d_xEnd = point.x();\n ++d_nPoints;\n\n if (d_nPoints == 1)\n {\n d_xStart = point.x();\n d_head = point;\n }\n else if (d_nPoints == 2)\n d_head = point;\n else\n {\n d_head = Eigen::Vector2f{point.x(), getY(point.x())};\n }\n d_dirty = true;\n }\n \n void solve()\n {\n if (d_dirty && d_nPoints > 1)\n {\n d_beta = (d_xxSum / d_nPoints).inverse() * d_xySum / d_nPoints;\n d_dirty = false;\n }\n }\n \n Eigen::Vector2f getBeta() const\n {\n return d_beta;\n }\n\n LineSegment2f getLineSegment()\n {\n solve();\n Eigen::Vector2f p1{d_xStart, getY(d_xStart)};\n Eigen::Vector2f p2{d_xEnd, getY(d_xEnd)};\n return LineSegment2f{p1, p2};\n }\n\n unsigned getNPoints() const\n {\n return d_nPoints;\n }\n\n float determineStandardError() const\n {\n auto X = Eigen::MatrixXf(2, d_points.size());\n auto y = Eigen::VectorXf(d_points.size());\n unsigned idx = 0;\n for (auto const& point : d_points)\n {\n X.col(idx) = Eigen::Vector2f{point.x(), 1};\n y(idx) = point.y();\n ++idx;\n }\n auto res = y - X.transpose() * d_beta;\n return sqrt(res.dot(res) / (d_points.size() - 2));\n }\n\n void merge(IncrementalRegression const& other)\n {\n d_xxSum += other.d_xxSum;\n d_xySum += other.d_xySum;\n d_nPoints += other.d_nPoints;\n d_xStart = std::min(d_xStart, other.d_xStart);\n d_xEnd = std::max(d_xEnd, other.d_xEnd);\n solve();\n }\n\nprivate:\n std::vector d_points;\n\n Eigen::Matrix2f d_xxSum;\n Eigen::Vector2f d_xySum;\n unsigned d_nPoints;\n Eigen::Vector2f d_beta;\n unsigned d_xStart;\n unsigned d_xEnd;\n Eigen::Vector2f d_head;\n float d_sqErrorSum;\n\n bool d_dirty;\n };\n}\n", "meta": {"hexsha": "930ae8ddc7581daf1b3fe5a9f2e6ea780b9c6319", "size": 3327, "ext": "hh", "lang": "C++", "max_stars_repo_path": "IncrementalRegression/incrementalregression.hh", "max_stars_repo_name": "drewnoakes/bold-humanoid", "max_stars_repo_head_hexsha": "6025fcc92cdf3ce9486d4fe5af4f30ee7a7a3335", "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": "IncrementalRegression/incrementalregression.hh", "max_issues_repo_name": "drewnoakes/bold-humanoid", "max_issues_repo_head_hexsha": "6025fcc92cdf3ce9486d4fe5af4f30ee7a7a3335", "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": "IncrementalRegression/incrementalregression.hh", "max_forks_repo_name": "drewnoakes/bold-humanoid", "max_forks_repo_head_hexsha": "6025fcc92cdf3ce9486d4fe5af4f30ee7a7a3335", "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": 21.464516129, "max_line_length": 82, "alphanum_fraction": 0.5494439435, "num_tokens": 970, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998611746911, "lm_q2_score": 0.640635861701035, "lm_q1q2_score": 0.49796616636374313}} {"text": "// This file is part of libigl, a simple c++ geometry processing library.\n//\n// Copyright (C) 2014 Alec Jacobson \n//\n// This Source Code Form is subject to the terms of the Mozilla Public License\n// v. 2.0. If a copy of the MPL was not distributed with this file, You can\n// obtain one at http://mozilla.org/MPL/2.0/.\n#include \"harmonic.h\"\n#include \"adjacency_matrix.h\"\n#include \"cotmatrix.h\"\n#include \"diag.h\"\n#include \"invert_diag.h\"\n#include \"isdiag.h\"\n#include \"massmatrix.h\"\n#include \"min_quad_with_fixed.h\"\n#include \"speye.h\"\n#include \"sum.h\"\n#include \n\ntemplate <\n typename DerivedV,\n typename DerivedF,\n typename Derivedb,\n typename Derivedbc,\n typename DerivedW>\nIGL_INLINE bool igl::harmonic(\n const Eigen::PlainObjectBase & V,\n const Eigen::PlainObjectBase & F,\n const Eigen::PlainObjectBase & b,\n const Eigen::PlainObjectBase & bc,\n const int k,\n Eigen::PlainObjectBase & W)\n{\n using namespace Eigen;\n typedef typename DerivedV::Scalar Scalar;\n SparseMatrix L,M;\n cotmatrix(V,F,L);\n massmatrix(V,F,MASSMATRIX_TYPE_DEFAULT,M);\n return harmonic(L,M,b,bc,k,W);\n}\n\ntemplate <\n typename DerivedF,\n typename Derivedb,\n typename Derivedbc,\n typename DerivedW>\nIGL_INLINE bool igl::harmonic(\n const Eigen::PlainObjectBase & F,\n const Eigen::PlainObjectBase & b,\n const Eigen::PlainObjectBase & bc,\n const int k,\n Eigen::PlainObjectBase & W)\n{\n using namespace Eigen;\n typedef typename Derivedbc::Scalar Scalar;\n SparseMatrix A;\n adjacency_matrix(F,A);\n // sum each row\n SparseVector Asum;\n sum(A,1,Asum);\n // Convert row sums into diagonal of sparse matrix\n SparseMatrix Adiag;\n diag(Asum,Adiag);\n SparseMatrix L = A-Adiag;\n SparseMatrix M;\n speye(L.rows(),M);\n return harmonic(L,M,b,bc,k,W);\n}\n\ntemplate <\n typename DerivedL,\n typename DerivedM,\n typename Derivedb,\n typename Derivedbc,\n typename DerivedW>\nIGL_INLINE bool igl::harmonic(\n const Eigen::SparseMatrix & L,\n const Eigen::SparseMatrix & M,\n const Eigen::PlainObjectBase & b,\n const Eigen::PlainObjectBase & bc,\n const int k,\n Eigen::PlainObjectBase & W)\n{\n const int n = L.rows();\n assert(n == L.cols() && \"L must be square\");\n assert(n == M.cols() && \"M must be same size as L\");\n assert(n == M.rows() && \"M must be square\");\n assert(igl::isdiag(M) && \"Mass matrix should be diagonal\");\n\n Eigen::SparseMatrix Q;\n igl::harmonic(L,M,k,Q);\n\n typedef DerivedL Scalar;\n min_quad_with_fixed_data data;\n min_quad_with_fixed_precompute(Q,b,Eigen::SparseMatrix(),true,data);\n W.resize(n,bc.cols());\n typedef Eigen::Matrix VectorXS;\n const VectorXS B = VectorXS::Zero(n,1);\n for(int w = 0;w\nIGL_INLINE void igl::harmonic(\n const Eigen::SparseMatrix & L,\n const Eigen::SparseMatrix & M,\n const int k,\n Eigen::SparseMatrix & Q)\n{\n assert(L.rows() == L.cols()&&\"L should be square\");\n assert(M.rows() == M.cols()&&\"M should be square\");\n assert(L.rows() == M.rows()&&\"L should match M's dimensions\");\n Eigen::SparseMatrix Mi;\n invert_diag(M,Mi);\n Q = -L;\n for(int p = 1;p\nIGL_INLINE void igl::harmonic(\n const Eigen::PlainObjectBase & V,\n const Eigen::PlainObjectBase & F,\n const int k,\n Eigen::SparseMatrix & Q)\n{\n Eigen::SparseMatrix L,M;\n cotmatrix(V,F,L);\n massmatrix(V,F,MASSMATRIX_TYPE_DEFAULT,M);\n return harmonic(L,M,k,Q);\n}\n\n#ifdef IGL_STATIC_LIBRARY\n// Explicit template specialization\ntemplate bool igl::harmonic, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix >(Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, int, Eigen::PlainObjectBase >&);\ntemplate bool igl::harmonic, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix >(Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, int, Eigen::PlainObjectBase >&);\ntemplate bool igl::harmonic, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix >(Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, int, Eigen::PlainObjectBase >&);\n\ntemplate bool igl::harmonic, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix >(Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, int, Eigen::PlainObjectBase >&);\ntemplate bool igl::harmonic, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix >(Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, int, Eigen::PlainObjectBase >&);\ntemplate bool igl::harmonic, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix >(Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, int, Eigen::PlainObjectBase >&);\ntemplate void igl::harmonic, Eigen::Matrix, double>(Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, int, Eigen::SparseMatrix&);\n#endif\n", "meta": {"hexsha": "a1a28804163a7fda532d96d084aa171aecf784f1", "size": 7609, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Source/SprueEngine/Libs/igl/harmonic.cpp", "max_stars_repo_name": "Qt-Widgets/TexGraph", "max_stars_repo_head_hexsha": "8fe72cea1afcf5e235c810003bf4ee062bb3fc13", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 35.0, "max_stars_repo_stars_event_min_datetime": "2017-04-07T22:49:41.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-03T13:59:20.000Z", "max_issues_repo_path": "Source/SprueEngine/Libs/igl/harmonic.cpp", "max_issues_repo_name": "Qt-Widgets/TexGraph", "max_issues_repo_head_hexsha": "8fe72cea1afcf5e235c810003bf4ee062bb3fc13", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2017-04-13T17:43:54.000Z", "max_issues_repo_issues_event_max_datetime": "2017-04-15T04:17:37.000Z", "max_forks_repo_path": "Source/SprueEngine/Libs/igl/harmonic.cpp", "max_forks_repo_name": "Qt-Widgets/TexGraph", "max_forks_repo_head_hexsha": "8fe72cea1afcf5e235c810003bf4ee062bb3fc13", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2019-03-11T19:26:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-04T07:17:10.000Z", "avg_line_length": 47.2608695652, "max_line_length": 596, "alphanum_fraction": 0.6526481798, "num_tokens": 2695, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998560157665, "lm_q2_score": 0.6406358479787609, "lm_q1q2_score": 0.4979661523924293}} {"text": "// BSD 3-Clause License\n\n// Copyright (c) 2021, Chenyu\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\n// 1. Redistributions of source code must retain the above copyright notice,\n// this\n// list of conditions and the following disclaimer.\n\n// 2. 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// 3. 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\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// edited by Steffen Urban (urbste@googlemail.com), August 2021\n\n#include \"theia/math/rank_restricted_sdp_solver.h\"\n\n#include \n#include \n\n#include \n#include \n\nnamespace theia {\nnamespace math {\n\nRankRestrictedSDPSolver::RankRestrictedSDPSolver(const size_t n,\n const size_t block_dim)\n : RankRestrictedSDPSolver(n, block_dim, math::SDPSolverOptions()) {}\n\nRankRestrictedSDPSolver::RankRestrictedSDPSolver(\n const size_t n,\n const size_t block_dim,\n const math::SDPSolverOptions& options)\n : BCMSDPSolver(n, block_dim, options), rank_(3) {\n Y_ = Eigen::MatrixXd::Zero(rank_, dim_ * n_);\n}\n\nvoid RankRestrictedSDPSolver::Solve(math::Summary& summary) {\n Eigen::MatrixXd G = Eigen::MatrixXd::Zero(rank_, dim_ * n_);\n\n#pragma omp parallel for num_threads(sdp_solver_options_.num_threads)\n // Compute inital G according to Equ.(3)\n for (size_t i = 0; i < n_; i++) {\n const std::vector& adjs = adj_edges_[i];\n for (auto j : adjs) {\n G.block(0, i * dim_, rank_, dim_) +=\n Y_.block(0, j * dim_, rank_, dim_) *\n Q_.block(j * dim_, i * dim_, dim_, dim_);\n }\n }\n\n double prev_func_val = std::numeric_limits::max();\n double cur_func_val = this->EvaluateFuncVal();\n double duration = 0.0;\n double error = 0.0;\n\n summary.begin_time = std::chrono::high_resolution_clock::now();\n while (summary.total_iterations_num < sdp_solver_options_.max_iterations) {\n if (sdp_solver_options_.verbose) {\n LogToStd(summary.total_iterations_num,\n prev_func_val,\n cur_func_val,\n error,\n duration);\n }\n\n if (IsConverge(prev_func_val,\n cur_func_val,\n sdp_solver_options_.tolerance,\n &error)) {\n break;\n }\n\n for (size_t i = 0; i < n_; i++) {\n const Eigen::MatrixXd G_block = G.block(0, i * dim_, rank_, dim_);\n Eigen::JacobiSVD jacobi_svd(\n -G_block, Eigen::ComputeThinU | Eigen::ComputeThinV);\n\n const Eigen::MatrixXd prev_Y = Y_.block(0, i * dim_, rank_, dim_).eval();\n Y_.block(0, i * dim_, rank_, dim_) =\n jacobi_svd.matrixU() * jacobi_svd.matrixV().transpose();\n\n const std::vector& adjs = adj_edges_[i];\n#pragma omp parallel for num_threads(sdp_solver_options_.num_threads)\n for (size_t idx = 0; idx < adjs.size(); ++idx) {\n const size_t j = adjs[idx];\n G.block(0, j * dim_, rank_, dim_) +=\n (Y_.block(0, i * dim_, rank_, dim_) - prev_Y) *\n Q_.block(i * dim_, j * dim_, dim_, dim_);\n }\n }\n\n summary.total_iterations_num++;\n duration = summary.Duration();\n\n // Update function value\n prev_func_val = cur_func_val;\n cur_func_val = this->EvaluateFuncVal();\n }\n\n summary.total_iterations_num++;\n if (sdp_solver_options_.verbose) {\n LogToStd(summary.total_iterations_num,\n prev_func_val,\n cur_func_val,\n error,\n duration);\n }\n}\n\nEigen::MatrixXd RankRestrictedSDPSolver::GetSolution() const {\n Eigen::MatrixXd solution = Eigen::MatrixXd(dim_, dim_ * n_);\n for (size_t i = 0; i < n_; i++) {\n solution.block(0, dim_ * i, dim_, dim_) =\n Y_.block(0, 0, rank_, dim_).transpose() *\n Y_.block(0, dim_ * i, rank_, dim_);\n }\n return solution;\n}\n\nconst Eigen::MatrixXd& RankRestrictedSDPSolver::GetYStar() const { return Y_; }\n\nconst Eigen::MatrixXd RankRestrictedSDPSolver::ComputeQYt(\n const Eigen::MatrixXd& Y) const {\n return Q_ * Y.transpose();\n}\n\nEigen::MatrixXd RankRestrictedSDPSolver::ComputeLambdaMatrix() const {\n const Eigen::MatrixXd QYt = this->ComputeQYt(Y_);\n\n const size_t rank = Y_.rows();\n // \\Lambda = \\SymblockDiag(Q * Y^T * Y).\n Eigen::MatrixXd Lambda = Eigen::MatrixXd::Zero(dim_, n_ * dim_);\n\n#pragma omp parallel for num_threads(sdp_solver_options_.num_threads)\n for (size_t i = 0; i < n_; ++i) {\n Eigen::MatrixXd P =\n QYt.block(i * dim_, 0, dim_, rank) * Y_.block(0, i * dim_, rank, dim_);\n Lambda.block(0, i * dim_, dim_, dim_) = 0.5 * (P + P.transpose());\n }\n\n return Lambda;\n}\n\ndouble RankRestrictedSDPSolver::EvaluateFuncVal() const {\n // tr(Q * Y^T * Y) = tr(Y * Q * Y^T)\n // return (Q_ * Y_.transpose() * Y_).trace();\n return (Y_ * (Q_ * Y_.transpose())).trace();\n}\n\ndouble RankRestrictedSDPSolver::EvaluateFuncVal(\n const Eigen::MatrixXd& Y) const {\n return (Y * (Q_ * Y.transpose())).trace();\n}\n\nvoid RankRestrictedSDPSolver::AugmentRank() {\n rank_++;\n Y_.conservativeResize(Y_.rows() + 1, Y_.cols());\n Y_.row(Y_.rows() - 1).setZero();\n}\n\nvoid RankRestrictedSDPSolver::SetOptimalY(const Eigen::MatrixXd& Y) {\n CHECK_EQ(Y.rows(), Y_.rows());\n CHECK_EQ(Y.cols(), Y_.cols());\n Y_ = Y;\n}\n\nsize_t RankRestrictedSDPSolver::CurrentRank() const { return rank_; }\n\nEigen::MatrixXd RankRestrictedSDPSolver::Project(\n const Eigen::MatrixXd& A) const {\n // We use a generalization of the well-known SVD-based projection for the\n // orthogonal and special orthogonal groups; see for example Proposition 7\n // in the paper \"Projection-Like Retractions on Matrix Manifolds\" by Absil\n // and Malick.\n\n Eigen::MatrixXd P(rank_, dim_ * n_);\n\n#pragma omp parallel for num_threads(sdp_solver_options_.num_threads)\n for (size_t i = 0; i < n_; ++i) {\n // Compute the (thin) SVD of the ith block of A\n Eigen::JacobiSVD SVD(\n A.block(0, i * dim_, rank_, dim_),\n Eigen::ComputeThinU | Eigen::ComputeThinV);\n\n // Set the ith block of P to the SVD-based projection of the ith block of A\n P.block(0, i * dim_, rank_, dim_) =\n SVD.matrixU() * SVD.matrixV().transpose();\n }\n return P;\n}\n\nEigen::MatrixXd RankRestrictedSDPSolver::Retract(\n const Eigen::MatrixXd& Y, const Eigen::MatrixXd& V) const {\n // We use projection-based retraction, as described in \"Projection-Like\n // Retractions on Matrix Manifolds\" by Absil and Malick.\n return Project(Y + V);\n}\n\nEigen::MatrixXd RankRestrictedSDPSolver::EuclideanGradient(\n const Eigen::MatrixXd& Y) const {\n return 2.0 * (Q_ * Y.transpose()).transpose();\n}\n\nEigen::MatrixXd RankRestrictedSDPSolver::RiemannianGradient(\n const Eigen::MatrixXd& Y, const Eigen::MatrixXd& nablaF_Y) const {\n return TangentSpaceProjection(Y, nablaF_Y);\n}\n\nEigen::MatrixXd RankRestrictedSDPSolver::RiemannianGradient(\n const Eigen::MatrixXd& Y) const {\n return TangentSpaceProjection(Y, EuclideanGradient(Y));\n}\n\nEigen::MatrixXd RankRestrictedSDPSolver::TangentSpaceProjection(\n const Eigen::MatrixXd& Y, const Eigen::MatrixXd& dotY) const {\n return dotY - SymBlockDiagProduct(Y, Y, dotY);\n}\n\nEigen::MatrixXd RankRestrictedSDPSolver::SymBlockDiagProduct(\n const Eigen::MatrixXd& A,\n const Eigen::MatrixXd& B,\n const Eigen::MatrixXd& C) const {\n // Preallocate result matrix\n Eigen::MatrixXd R(rank_, dim_ * n_);\n\n#pragma omp parallel for num_threads(sdp_solver_options_.num_threads)\n for (size_t i = 0; i < n_; ++i) {\n // Compute block product Bi' * Ci.\n Eigen::MatrixXd P = B.block(0, i * dim_, rank_, dim_).transpose() *\n C.block(0, i * dim_, rank_, dim_);\n // Symmetrize this block.\n Eigen::MatrixXd S = 0.5 * (P + P.transpose());\n // Compute Ai * S and set corresponding block of R.\n R.block(0, i * dim_, rank_, dim_) = A.block(0, i * dim_, rank_, dim_) * S;\n }\n return R;\n}\n\nEigen::MatrixXd RankRestrictedSDPSolver::Precondition(\n const Eigen::MatrixXd& Y, const Eigen::MatrixXd& dotY) const {\n switch (sdp_solver_options_.preconditioner_type) {\n case PreconditionerType::None:\n return dotY;\n break;\n case PreconditionerType::JACOBI:\n /* code */\n break;\n case PreconditionerType::INCOMPLETE_CHOLESKY:\n /* code */\n break;\n case PreconditionerType::REGULARIZED_CHOLESKY:\n default:\n break;\n }\n}\n\n} // namespace math\n} // namespace theia\n", "meta": {"hexsha": "f36f75026dcdb71e89bc37804933ff8c24b0035a", "size": 9562, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/theia/math/rank_restricted_sdp_solver.cc", "max_stars_repo_name": "urbste/TheiaSfM", "max_stars_repo_head_hexsha": "a92fa27e90b6182e2a2511a46d24283afad1a995", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2019-12-25T03:01:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-04T08:08:45.000Z", "max_issues_repo_path": "src/theia/math/rank_restricted_sdp_solver.cc", "max_issues_repo_name": "urbste/TheiaSfM", "max_issues_repo_head_hexsha": "a92fa27e90b6182e2a2511a46d24283afad1a995", "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/math/rank_restricted_sdp_solver.cc", "max_forks_repo_name": "urbste/TheiaSfM", "max_forks_repo_head_hexsha": "a92fa27e90b6182e2a2511a46d24283afad1a995", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-03-20T03:06:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-04T08:08:52.000Z", "avg_line_length": 34.15, "max_line_length": 79, "alphanum_fraction": 0.6737084292, "num_tokens": 2537, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619263765707, "lm_q2_score": 0.6039318337259584, "lm_q1q2_score": 0.4979188030338384}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace arma;\nusing namespace hsmm;\nusing namespace std;\n\n#define NDIM 2\n#define NDUR 70\n#define MINDUR 30\n#define NOISE_STDDEV 0.05\n\ndouble gaussianlogpdf_(double x, double mu, double sigma) {\n double ret = ((x - mu)*(x - mu)) / (-2*sigma*sigma);\n ret = ret - log(sqrt(2 * M_PI) * sigma);\n return ret;\n}\n\nmat fieldToMat(int njoints, field &samples) {\n mat ret(njoints, samples.n_elem);\n for(int i = 0; i < samples.n_elem; i++)\n ret.col(i) = samples(i);\n return ret;\n}\n\nvoid fillDurationMatrix(mat& duration, const ivec& centers) {\n assert(centers.n_elem == duration.n_rows);\n duration.zeros();\n //vec pmf_pattern = {0.1, 0.2, 0.4, 0.2, 0.1};\n vec pmf_pattern(20);\n pmf_pattern.fill(1.0/pmf_pattern.n_elem);\n for(int i = 0; i < centers.n_elem; i++) {\n int m = centers(i);\n int half = pmf_pattern.n_elem / 2;\n for(int j = 0; j < pmf_pattern.n_elem; j++)\n duration(i, m - half + j) = pmf_pattern(j);\n }\n}\n\nclass ToyEmission : public AbstractEmissionOnlineSetting {\n public:\n ToyEmission(vector> states, int ndim,\n double noise_stddev) : states_(states),\n AbstractEmissionOnlineSetting(states.size(), ndim) {\n output_gaussian_stddev_ = ones(getDimension(),\n getNumberStates()) * noise_stddev;\n }\n\n ToyEmission* clone() const {\n return new ToyEmission(*this);\n }\n\n vec getSampleLocations(int length) const {\n return linspace(0, 1.0, length);\n }\n\n double loglikelihood(int state, const field& obs) const {\n vec t = getSampleLocations(obs.n_elem);\n double ret = 0;\n for(int i = 0; i < obs.n_elem; i++) {\n // Making sure all the missing obs are at the end.\n // Other missing obs patterns are not supported yet.\n if (obs(i).is_empty()) {\n for(int j = i; j < obs.n_elem; j++)\n assert(obs(j).is_empty());\n break;\n }\n vec diff = obs(i) - states_.at(state)(t(i));\n for(int j = 0; j < diff.n_elem; j++)\n ret += gaussianlogpdf_(diff(j), 0,\n output_gaussian_stddev_(j, state));\n }\n return ret;\n }\n\n void reestimate(int min_duration, const field& meta,\n const field>& mobs ) {\n throw logic_error(\"Not implemented yet\");\n }\n\n field sampleFromState(int state, int nsegments,\n mt19937& rng) const {\n vec t = getSampleLocations(nsegments);\n field ret(nsegments);\n for(int i = 0; i < nsegments; i++) {\n ret(i) = randn(getDimension());\n ret(i) = ret(i) % output_gaussian_stddev_.col(state);\n ret(i) = ret(i) + states_.at(state)(t(i));\n }\n return ret;\n }\n\n field sampleNextObsGivenPastObs(int state, int seg_dur,\n const field& past_obs, mt19937 &rng) const {\n throw logic_error(\"Not implemented yet\");\n }\n\n private:\n vector> states_;\n mat output_gaussian_stddev_;\n};\n\nvec halfsine1(double t) {\n assert(t <= 1.0 && t >= 0);\n t = t * M_PI;\n vec ret = {sin(t), -sin(t)};\n return ret;\n}\n\nvec halfsine2(double t) {\n assert(t <= 1.0 && t >= 0);\n t = t * M_PI;\n vec ret = {-sin(t), sin(t)};\n return ret;\n}\n\nvec halfsine3(double t) {\n assert(t <= 1.0 && t >= 0);\n t = t * M_PI;\n vec ret = {0.5*sin(t), 0.25*sin(t)};\n return ret;\n}\n\nvec halfsine4(double t) {\n assert(t <= 1.0 && t >= 0);\n t = t * M_PI;\n vec ret = {-0.25*sin(t), -0.5*sin(t)};\n return ret;\n}\n\nint main(int arc, char* argv[]) {\n vector> states = {halfsine1, halfsine2,\n halfsine3, halfsine4};\n shared_ptr ptr_emission(new ToyEmission(states, NDIM,\n NOISE_STDDEV));\n vec pi(states.size());\n mat transition(states.size(), states.size());\n mat duration(states.size(), NDUR, fill::zeros);\n\n // Init the parameters.\n pi.fill(1.0 / states.size());\n transition.fill(1.0 / (states.size() - 1));\n transition.diag().zeros();\n ivec duration_centers = {15, 30, 45, 60};\n fillDurationMatrix(duration, duration_centers);\n\n OnlineHSMM online_toy_model(static_pointer_cast<\n AbstractEmissionOnlineSetting>(ptr_emission), transition, pi,\n duration, MINDUR);\n int nsegments = 12;\n ivec hs, hd;\n field toy_seq = online_toy_model.sampleSegments(nsegments, hs, hd);\n int nobs = toy_seq.n_elem;\n imat vit_mat = join_horiz(hs, hd);\n cout << \"vit file\" << endl << vit_mat << endl;\n\n // Online inference.\n mat state_marginals(states.size(), nobs);\n mat runlength_marginals(MINDUR + NDUR, nobs);\n mat implicit_remaining_marginals(MINDUR + NDUR, nobs);\n mat duration_marginals(NDUR, nobs);\n mat implicit_duration_marginals(NDUR, nobs);\n for(int c = 0; c < nobs; c++) {\n cout << \"time step: \" << c << endl;\n online_toy_model.addNewObservation(toy_seq(c));\n state_marginals.col(c) = online_toy_model.getStateMarginal();\n runlength_marginals.col(c) = online_toy_model.getRunlengthMarginal();\n duration_marginals.col(c) = online_toy_model.getDurationMarginal();\n implicit_remaining_marginals.col(c) = online_toy_model.\n getImplicitResidualTimeMarginal();\n //implicit_duration_marginals.col(c) = online_toy_model.\n // getImplicitDurationMarginal();\n }\n\n // Saving everything.\n string prefix = \"/local_data/dagudelo/paper_synth_experiment/\";\n mat output = fieldToMat(NDIM, toy_seq);\n output.save(prefix + \"paper_synth_obs.txt\", raw_ascii);\n vit_mat.save(prefix + \"paper_synth_gt_vit_seq.txt\", raw_ascii);\n state_marginals.save(prefix + \"paper_synth_mstates.txt\", raw_ascii);\n runlength_marginals.save(prefix + \"paper_synth_runlength.txt\", raw_ascii);\n duration_marginals.save(prefix + \"paper_synth_duration.txt\", raw_ascii);\n implicit_remaining_marginals.save(prefix + \"paper_synth_remaining.txt\",\n raw_ascii);\n //implicit_duration_marginals.save(prefix + \"paper_synth_impli_duration.txt\",\n // raw_ascii);\n return 0;\n}\n", "meta": {"hexsha": "e0f28f47c68b592b39fd753e44ea6877ae961d81", "size": 6594, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/paper_synth_exp.cpp", "max_stars_repo_name": "DiegoAE/BOSD", "max_stars_repo_head_hexsha": "a7ce88462c64c540ba2922d16eb6f7eba8055b47", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 19.0, "max_stars_repo_stars_event_min_datetime": "2019-05-03T05:31:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-08T18:14:31.000Z", "max_issues_repo_path": "examples/paper_synth_exp.cpp", "max_issues_repo_name": "DiegoAE/BOSD", "max_issues_repo_head_hexsha": "a7ce88462c64c540ba2922d16eb6f7eba8055b47", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2019-02-14T15:29:34.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-04T10:14:54.000Z", "max_forks_repo_path": "examples/paper_synth_exp.cpp", "max_forks_repo_name": "DiegoAE/BOSD", "max_forks_repo_head_hexsha": "a7ce88462c64c540ba2922d16eb6f7eba8055b47", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-07-01T07:44:09.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-01T07:44:09.000Z", "avg_line_length": 34.1658031088, "max_line_length": 81, "alphanum_fraction": 0.5943281771, "num_tokens": 1752, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619263765707, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.49791880303383834}} {"text": "#include \n#include \n\n#include \n\n#include \n#include \n#include \n#include \n\nusing namespace arma;\n\nvoid\nset_missing_to_zero(const uvec &missing, vec &w)\n{ \n for(int i = 0; i < w.size( ); i++)\n {\n if( missing[ i ] == 1 )\n {\n w[ i ] = 0.0;\n }\n }\n}\n\nvec\nchi_square_cdf(const vec &x, unsigned int df)\n{\n vec p = ones( x.n_elem );\n for(int i = 0; i < x.n_elem; i++)\n {\n p[ i ] = chi_square_cdf( x[ i ], df );\n }\n\n return p;\n}\n\nvec\nweighted_least_squares(const mat &X, const vec &y, const vec &w, bool fast_inversion)\n{\n /* A = sqrt( w ) * X */\n mat A = diagmat( sqrt( w ) ) * X;\n\n /* ty = sqrt( w ) * y */\n vec ty = y % sqrt( w );\n\n vec beta;\n if( fast_inversion )\n {\n if( solve( beta, A, ty, solve_opts::fast + solve_opts::no_approx ) )\n {\n return beta;\n }\n else\n {\n return vec( );\n }\n }\n else\n {\n if( solve( beta, A, ty ) )\n {\n return beta;\n }\n else\n {\n return vec( );\n }\n }\n}\n\nvec\ncompute_z(const vec &eta, const vec &mu, const vec &mu_eta, const vec &y)\n{\n return eta + mu_eta % ( y - mu );\n}\n\nvec\ncompute_w(const vec &var, const vec& mu_eta)\n{\n return 1.0 / ( var % ( mu_eta % mu_eta ) );\n}\n\nvec\ninit_beta(const mat &X, const vec&y, const uvec &missing, const glm_model &model, bool fast_inversion = false)\n{\n vec eta = model.get_link( ).eta( (y + 0.5) / 3.0 );\n\n return weighted_least_squares( X, eta, ones( missing.n_elem ) - missing, fast_inversion );\n}\n\nvec\nirls(const mat &X, const vec &y, const uvec &missing, const glm_model &model, glm_info &output, bool fast_inversion)\n{\n const glm_link &link = model.get_link( );\n vec b = init_beta( X, y, missing, model );\n vec w( X.n_rows );\n vec z( X.n_rows );\n vec eta = X * b;\n vec mu = link.mu( eta );\n\n vec mu_eta = link.mu_eta( mu );\n\n int num_iter = 0;\n double old_logl = -DBL_MAX;\n double logl = model.likelihood( mu, y, missing );\n bool invalid_mu = false;\n bool inverse_fail = false;\n vec b_old = b;\n bool first_attempt = true;\n while( num_iter < IRLS_MAX_ITERS && ! ( fabs( logl - old_logl ) / ( 0.1 + fabs( logl ) ) < IRLS_TOLERANCE ) )\n {\n w = compute_w( model.var( mu ), mu_eta );\n z = compute_z( eta, mu, mu_eta, y );\n set_missing_to_zero( missing, w );\n b = weighted_least_squares( X, z, w, fast_inversion );\n if( b.n_elem <= 0 )\n {\n inverse_fail = true;\n break;\n }\n\ncompute_eta: \n eta = X * b;\n mu = link.mu( eta );\n mu_eta = link.mu_eta( mu );\n\n if( !model.valid_mu( mu ) )\n {\n if( first_attempt )\n {\n /* Try a smaller step */\n b = 0.5*b_old + 0.5*b;\n first_attempt = false;\n goto compute_eta;\n }\n else\n {\n invalid_mu = true;\n break;\n }\n }\n\n old_logl = logl;\n b_old = b;\n logl = model.likelihood( mu, y, missing );\n\n num_iter++;\n }\n\n if( num_iter < IRLS_MAX_ITERS && !invalid_mu && !inverse_fail )\n {\n mat I = X.t( ) * diagmat( w ) * X;\n mat C;\n if( I.is_finite( ) && inv( C, I ) )\n {\n float dispersion = model.dispersion( mu, y, missing, b.n_elem );\n output.se_beta = sqrt( model.dispersion( mu, y, missing, dispersion ) * diagvec( C ) );\n output.num_iters = num_iter;\n output.converged = true;\n output.success = true;\n output.mu = mu;\n output.logl = model.likelihood( mu, y, missing, dispersion );\n \n vec wald_z = b / output.se_beta;\n vec chi2_value = wald_z % wald_z;\n output.p_value = -1.0 * ones( chi2_value.n_elem );\n for(int i = 0; i < chi2_value.n_elem; i++)\n {\n try\n {\n output.p_value[ i ] = 1.0 - chi_square_cdf( chi2_value[ i ], 1 );\n }\n catch(bad_domain_value &e)\n {\n continue;\n }\n }\n }\n else\n {\n output.success = false;\n }\n }\n else\n { \n output.num_iters = num_iter;\n output.converged = false;\n output.success = false;\n }\n\n return b;\n}\n\nvec\nirls(const mat &X, const vec &y, const glm_model &model, glm_info &output, bool fast_inversion)\n{\n uvec missing = zeros( y.n_elem );\n return irls( X, y, missing, model, output );\n}\n", "meta": {"hexsha": "9a65d08074b09d26d237fea5b653bd1c67b632da", "size": 4822, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/glm/irls.cpp", "max_stars_repo_name": "hoehleatsu/besiq", "max_stars_repo_head_hexsha": "94959e2819251805e19311ce377919e6bccb7bf9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-10-21T14:22:12.000Z", "max_stars_repo_stars_event_max_datetime": "2015-10-21T14:22:12.000Z", "max_issues_repo_path": "libs/glm/irls.cpp", "max_issues_repo_name": "hoehleatsu/besiq", "max_issues_repo_head_hexsha": "94959e2819251805e19311ce377919e6bccb7bf9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2019-05-26T20:52:31.000Z", "max_issues_repo_issues_event_max_datetime": "2019-05-28T16:19:49.000Z", "max_forks_repo_path": "libs/glm/irls.cpp", "max_forks_repo_name": "hoehleatsu/besiq", "max_forks_repo_head_hexsha": "94959e2819251805e19311ce377919e6bccb7bf9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2016-11-06T14:58:37.000Z", "max_forks_repo_forks_event_max_datetime": "2019-05-26T14:03:13.000Z", "avg_line_length": 24.11, "max_line_length": 116, "alphanum_fraction": 0.4981335545, "num_tokens": 1347, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619091240701, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.49791879261450406}} {"text": "/**\n * @file IndexGraph.hpp\n * @author bwu\n * @brief Model of index graph concept and graph related algorithms\n * @version 0.1\n * @date 2022-02-22\n */\n#ifndef GENERIC_TOPOLOGY_INDEXGRAPH_HPP\n#define GENERIC_TOPOLOGY_INDEXGRAPH_HPP\n#include \"generic/common/Exception.hpp\"\n#include \"generic/common/Archive.hpp\"\n#include \"Common.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace generic {\nnamespace topology {\n\n///@brief represents model of undirected index edge concept\nstruct UndirectedIndexEdge\n{\n ///@brief constructs an invalid edge\n UndirectedIndexEdge()\n {\n m_vertices = std::make_pair(noIndex, noIndex);\n }\n\n ///@brief constructs an undirected edge with vertex `iv1` and `iv2`\n UndirectedIndexEdge(index_t iv1, index_t iv2)\n {\n SetVertices(iv1, iv2);\n }\n\n ///@brief checks if this edge equals to `e`\n bool operator==(const UndirectedIndexEdge & e) const { return m_vertices == e.m_vertices; }\n ///@brief checks if this edge not equals to `e`\n bool operator!=(const UndirectedIndexEdge & e) const { return !(*this == e); }\n\n ///@brief set two vertices index of this edges\n void SetVertices(index_t iv1, index_t iv2) { m_vertices.first = std::min(iv1, iv2); m_vertices.second = std::max(iv1, iv2); }\n\n ///@brief returns the smaller vertex index of this edge\n index_t v1() const { return m_vertices.first ; }\n ///@brief returns the bigger vertex index of this edge\n index_t v2() const { return m_vertices.second; }\n\n ///@brief chechks if this edge contains vertex `iv`\n bool hasVertex(index_t iv) const { return iv == m_vertices.first || iv == m_vertices.second; }\n\nprivate:\n std::pair m_vertices;\n\n#ifdef BOOST_SERIALIZATION_SUPPORT\nprivate:\n friend class boost::serialization::access;\n template \n void serialize(Archive & ar, const unsigned int)\n {\n ar & m_vertices;\n }\n#endif\n};\n\nstruct UndirectedIndexEdgeHash\n{\n size_t operator() (const UndirectedIndexEdge & edge) const noexcept\n {\n size_t seed(0);\n boost::hash_combine(seed, edge.v1());\n boost::hash_combine(seed, edge.v2());\n return seed;\n }\n};\n\nstruct UndirectedIndexEdgeCompare\n{\n bool operator() (const UndirectedIndexEdge & e1, const UndirectedIndexEdge & e2) const noexcept { return e1 == e2; }\n};\n\nusing UndirectedIndexEdgeSet = std::unordered_set;\n\ntemplate \nusing UndirectedIndexEdgeMap = std::unordered_map;\n\n///@brief represents model of sparse undirect index graph concept\nusing SparseIndexGraph = boost::adjacency_list<\n boost::setS,\n boost::vecS,\n boost::undirectedS,\n boost::property\n >;\n\nusing SIGEdge = boost::graph_traits::edge_descriptor; \nusing SIGEdgeIter = boost::graph_traits::edge_iterator;\nusing SIGVertex = boost::graph_traits::vertex_descriptor;\n\ninline void AddEdge(index_t i, index_t j, SparseIndexGraph & g)\n{\n boost::add_edge(i, j, g);\n}\n\ninline std::pair Edges(const SparseIndexGraph & g)\n{\n return boost::edges(g);\n}\n\ninline SIGVertex Source(const SIGEdge & e, const SparseIndexGraph & g)\n{\n return boost::source(e, g);\n}\n\ninline SIGVertex Target(const SIGEdge & e, const SparseIndexGraph & g)\n{\n return boost::target(e, g);\n}\n\n/**\n * @brief gets connected component by BFS\n * \n * @param[in] g the connection graph\n * @param[in] v the source vertex\n * @param[out] c contains the vertices connected to source v\n */\ninline void ConnectedComponent(const SparseIndexGraph & g, const index_t v, std::list & c)\n{\n using namespace boost;\n GENERIC_ASSERT(v < num_vertices(g))\n\n class BFSVisitor : public default_bfs_visitor\n {\n public:\n std::list & visited;\n BFSVisitor(std::list & _visited) : visited(_visited) {}\n void discover_vertex(index_t s, const SparseIndexGraph &) { visited.push_back(s); }\n };\n\n c.clear();\n BFSVisitor vis(c);\n breadth_first_search(g, v, visitor(vis));\n}\n\n/**\n * @brief gets all connected components from graph\n * \n * @param[in] g the connection graph\n * @param[out] cc connected components\n */\ninline void ConnectedComponents(const SparseIndexGraph & g, std::vector > & cc)\n{\n using namespace boost;\n std::vector c(num_vertices(g));\n auto numComp = connected_components(g, make_iterator_property_map(c.begin(), get(vertex_index, g)));\n\n cc.clear();\n cc.resize(numComp);\n for(size_t i = 0; i < c.size(); ++i)\n cc[c[i]].push_back(i);\n}\n\ninline UndirectedIndexEdgeSet EdgeSet(const SparseIndexGraph & g)\n{\n UndirectedIndexEdgeSet edgeSet;\n auto [begin, end] = topology::Edges(g);\n for(auto iter = begin; iter != end; ++iter){\n auto u = topology::Source(*iter, g);\n auto v = topology::Target(*iter, g);\n edgeSet.insert(UndirectedIndexEdge{u, v});\n }\n return edgeSet;\n}\n\n}//namespace topology\n}//namespace generic\n#endif//GENERIC_TOPOLOGY_INDEXGRAPH_HPP", "meta": {"hexsha": "b5d28f83b5cb17f43a5305c21db7499ef262521e", "size": 5629, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "topology/IndexGraph.hpp", "max_stars_repo_name": "Draaaaaaven/generic", "max_stars_repo_head_hexsha": "f72a1896058486ef865cb2a0a722d70b2398a7af", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2022-01-05T02:34:04.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-19T13:51:50.000Z", "max_issues_repo_path": "topology/IndexGraph.hpp", "max_issues_repo_name": "Draaaaaaven/generic", "max_issues_repo_head_hexsha": "f72a1896058486ef865cb2a0a722d70b2398a7af", "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": "topology/IndexGraph.hpp", "max_forks_repo_name": "Draaaaaaven/generic", "max_forks_repo_head_hexsha": "f72a1896058486ef865cb2a0a722d70b2398a7af", "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": 31.0994475138, "max_line_length": 129, "alphanum_fraction": 0.6931959495, "num_tokens": 1383, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6959583376458152, "lm_q2_score": 0.7154239897159439, "lm_q1q2_score": 0.49790529059464506}} {"text": "/*\n * util.hh\n *\n * Created on: May 3, 2015\n * Author: sunayana_ghosh\n */\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */\n/* */\n/* This file is part of the library KASKADE 7 */\n/* see http://www.zib.de/projects/kaskade7-finite-element-toolbox */\n/* */\n/* Copyright (C) 2015-2015 Zuse Institute Berlin */\n/* */\n/* KASKADE 7 is distributed under the terms of the ZIB Academic License. */\n/* see $KASKADE/academic.txt */\n/* */\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */\n\n//In this file we implement some of the utility functions necessary for\n//the classes WorkModel, ErrorEstimate and the main integrate function of the class EulerSDC.\n\n#ifndef KASKADE_TIMESTEPPING_EULERSDC_UTIL_HH_\n#define KASKADE_TIMESTEPPING_EULERSDC_UTIL_HH_\n\n#include \"norm.hh\"\n\n#include //std::abs\n#include //std::function\n#include \n\n#include \n\n#include \"dune/common/dynmatrix.hh\"\n#include \"dune/common/dynvector.hh\"\n\n#include \"fem/fixdune.hh\"\n#include \"timestepping/sdc.hh\"\n\nnamespace Kaskade {\n /**\n * \\ingroup eulerSDC\n * \\brief Some utility functions.\n */\n//=================================================================================================\n// Utility function to find norm of a difference of vector of two Vectors\n//=================================================================================================\n\n/**\n * \\ingroup eulerSDC\n * \\brief Function to compute the norm of the difference of two vector of Vectors.\n *\n * @param y0 : A vector of Vectors, usually of type std::vector\n * @param y1 : A vector of Vectors, usually of type std::vector\n * @param norm : A type of norm, in this case an object of type Kaskade::Norm\n * @return An object of type Vector::value_type is returned, it is usually a double.\n */\ntemplate\ntypename Vector::value_type normVecDiff(std::vector const& y0, std::vector const& y1, Norm norm);\n\n\n//=================================================================================================\n// Implementation for single sdc iteration step based on explicit Euler method.\n//=================================================================================================\n /**\n * \\ingroup eulerSDC\n * This function performs one spectral defect correction (SDC) iteration for a system of ODE's of the form:\n * \\f$ y'(t) = f(y(t)) \\f$, \\f$ y(0) = y_0\\f$ and \\f$ t \\in [0, T] \\f$,\n * using the explicit Euler method on a given time grid. Here SDC is interpreted as fixed point iteration.\n * Given an approximate solution \\f$ y^{[j]} \\in \\mathbb{P}_N \\f$, the error function\n * \\f[ \\delta^{[j]} = y - y^{[j]} \\f]\n * satisfies the defect equation\n * \\f[ \\delta^{[j]'}(t) = y'(t) - y^{[j]'}(t) = f(y(t)) - y^{[j]'}(t). \\f]\n * The equivalent Picard equation is\n * \\f[ \\delta^{[j]}(t) = \\int_{\\tau=0}^t \\left( f(y^{[j]}(\\tau)+\\delta^{[j]}(\\tau)) - y^{[j]'}(\\tau) \\,d\\tau\\right)\\f]\n * Evaluated at the grid nodes \\f$ t_i\\f$ we obtain\n * \\f{eqnarray*}{\n * \\delta^{[j]}_i & = & \\delta^{[j]}_{i-1} + \\int_{\\tau=t_{i-1}}^{t_i} \\left( f(y^{[j]}(\\tau)+\\delta^{[j]}(\\tau)) - {y^{[j]}}'(\\tau) \\right) \\,d\\tau \\\\\n * & = & \\delta^{[j]}_{i-1} + \\int_{\\tau=t_{i-1}}^{t_i} \\left( f(y^{[j]}(\\tau)+\\delta^{[j]}(\\tau)) - f(y^{[j]}(\\tau))\\right) \\,d\\tau\n * + \\int_{\\tau=t_{i-1}}^{t_i} \\hspace{-0.5em}f(y^{[j]}(\\tau)) \\,d\\tau - ( y^{[j]}_i-y^{[j]}_{i-1})\n * \\f}\n * starting at \\f$ \\delta_0^{[j]} = 0. \\f$ Using left looking rectangular rule for approximating the first integral, and the canonical quadrature by\n * polynomial interpolation on the nodes \\f$ t_1,\\ldots t_N \\f$ for second integral, approximate values \\f$ \\hat{\\delta}_i^{[j]} \\f$ for\n * \\f$ \\delta_i^{[j]} \\f$ can be evaluated. With the left looking rectangular rule, we obtain the explicit scheme\n * \\f{eqnarray*}{\n * \\hat\\delta^{[j]}_i & = & \\hat\\delta^{[j]}_{i-1}\n * + (t_i-t_{i-1}) \\left( f(y^{[j]}_{i-1}+\\hat{\\delta}^{[j]}_{i-1}) - f(y^{[j]}_{i-1})\\right)\n * + \\sum_{k=1}^N S_{ik} f(y^{[j]}_k) - y^{[j]}_i+y^{[j]}_{i-1},\n * \\f}\n * where the entries of the spectral quadrature matrix \\f$ S \\in \\mathbb{R}^{N \\times N} \\f$ are defined in terms of the Lagrange polynomials\n * \\f$ L_k \\in \\mathbb{P}_N \\f$ satisfying \\f$ L_k(t_i) = \\delta_{ik} \\f$ as\n * \\f{eqnarray*}{\n * S_{ik} & = & \\int_{\\tau=t_{i-1}}^{t_i} L_k(\\tau) \\,d\\tau, \\quad i,k =1,\\dots, N.\n * \\f}\n * An improved approximation \\f$ y^{[j+1]} \\f$ is then obtained by polynomial interpolation of \\f$ \\hat \\delta^{[j]}_i \\f$,\n * \\f{eqnarray*}{\n * y^{[j+1]} = y^{[j]} + \\hat\\delta^{[j]}.\n * \\f}\n *\n *\\tparam Vector a vector type, usually Dune::DenseVector.\n *\n * \\param[in] grid the collocation time grid\n * \\param[in] rhsFunc is the function which represents the right hand side \\f$ f \\f$ and is used in the computation of \\f$ \\delta y \\f$.\n * \\param[out] yi stores the current iterate of the solution \\f$ y \\f$.\n * \\param[out] dyi is the approximate correction \\f$ \\delta y \\f$\n * \\param[in] verbose a boolean used to print out the iterates of \\f$ y \\f$.\n *\n */\n\n template\n void sdcExplicitEulerIterationStep(Kaskade::SDCTimeGrid const& grid,\n std::function rhsFunc,\n std::vector & yi, std::vector & dyi,\n bool verbose = false)\n {\n //extract time points from the grid\n auto const& pts = grid.points();\n //extracting values of the integration matrix corresponding to the time grid.\n auto const& integ = grid.integrationMatrix();\n //number of intervals\n int const n = pts.size() - 1;\n\n //including starting point for yi and dyi\n assert(yi.size() == n+1);\n assert(dyi.size() == n+1);\n\n //initialize all elements of dyi to zero.\n for (int i = 0; i <= n; ++i)\n {\n dyi[i] = Vector(0.0);\n }\n\n //declare Vector total to be used inside the for loop\n Vector total(0.0);\n\n //the SDC step for explicit Euler\n //perform n Euler steps\n boost::timer::cpu_timer timer;\n for (auto i = 1; i <= n; ++i)\n {\n //Initialize all the entries of total to zero\n total = Vector(0.0);\n //computation of the Lagrange interpolation\n for (int k = 0; k <= n; ++k)\n {\n total += integ[i-1][k] * rhsFunc(pts[k], yi[k]);\n }\n //approximate correction computation\n dyi[i] = dyi[i-1] + (pts[i] - pts[i-1]) *(rhsFunc(pts[i-1],yi[i-1]+dyi[i-1]) - rhsFunc(pts[i-1],yi[i-1])) + total - yi[i] + yi[i-1];\n }\n\n //Compute the next iteration of yi.\n for (auto i = 0; i <= n; ++i)\n {\n yi[i] += dyi[i];\n if (verbose)\n std::cout << \"yi[\" << i << \"] = \" << yi[i] << \"\\n\";\n }\n\n }\n\n //=================================================================================================\n // Implementation for single inexact sdc iteration step based on explicit Euler method.\n //=================================================================================================\n\n\n template\n void inexactSDCExplicitEulerIterationStep(Kaskade::SDCTimeGrid const& grid,\n std::function rhsFunc,\n RealVector const& toleranceVector, typename Vector::value_type rho,\n Kaskade::NormType norm_t,\n std::vector & yi, std::vector & dyi,\n bool verbose = false)\n {\n //extract time points from the grid\n auto const& tpts = grid.points();\n //extracting values of the integration matrix corresponding to the time grid.\n auto const& integ = grid.integrationMatrix();\n //number of intervals\n unsigned int const n = tpts.size() - 1;\n\n //including starting point for yi and dyi\n assert(yi.size() == n+1);\n assert(dyi.size() == n+1);\n\n //initialize all elements of dyi to zero.\n for (auto i = 0u; i <= n; ++i)\n {\n dyi[i] = Vector(0.0);\n }\n\n //declare Vector total to be used inside the for loop\n Vector total(0.0);\n\n //convert the toleranceVector which is a vector of doubles to a vector of Vectors.\n std::vector errVector(n+1, Vector(0.0));\n //depending on the normType fill in err vector. This step is taken since the tolerance vector is a vector of scalars\n switch(norm_t)\n {\n case Kaskade::NormType::ONE_NORM:\n {\n auto sz = dyi[0].size();\n for (auto i = 1u; i <= n; ++i)\n errVector[i] = Vector(toleranceVector[i]/sz);\n break;\n }\n case Kaskade::NormType::MAX_NORM:\n {\n for (auto i = 1u; i <= n; ++i)\n errVector[i] = Vector(toleranceVector[i]);\n break;\n }\n }\n\n //the perturbed SDC step for explicit Euler\n //perform n Euler steps\n boost::timer::cpu_timer timer;\n for (auto i = 1u; i <= n; ++i)\n {\n //Initialize all the entries of total to zero\n total = Vector(0.0);\n\n //computation of the Lagrange interpolation\n for (auto k = 0u; k <= n; ++k)\n {\n total += integ[i-1][k] * (rhsFunc(tpts[k], yi[k]) + errVector[k]);\n }\n //approximate correction computation\n dyi[i] = dyi[i-1] + (tpts[i] - tpts[i-1]) *((rhsFunc(tpts[i-1],yi[i-1]+dyi[i-1]) - rhsFunc(tpts[i-1],yi[i-1]))- (1 - rho)*errVector[i-1]) + total - yi[i] + yi[i-1];\n }\n\n //Compute the next iteration of yi.\n for (auto i = 0u; i <= n; ++i)\n {\n yi[i] += dyi[i];\n if (verbose)\n std::cout << \"yi[\" << i << \"] = \" << yi[i] << \"\\n\";\n }\n }\n\n\n //===================================================================================================\n // Implementation of the abstract base class SDCUtil for all utility methods depending on the norms.\n //===================================================================================================\n\n template \n class SDCUtil\n {\n public:\n using field_type = typename Vector::value_type;\n using RealVector = Dune::DynamicVector;\n using RealMatrix = Dune::DynamicMatrix;\n\n //virtual function\n /**\n * \\ingroup eulerSDC\n * This function computes an estimate of the SDC contraction factor (\\f$ \\rho \\f$) given three consecutive iterations of \\f$ y \\f$ and\n * depends on the given norm.\n * The estimate of \\f$ \\rho \\f$ is given by:\n * \\f{eqnarray*}{\n * \\rho & = & \\frac{\\|y^{[j+1]} - y^{[j]}\\|}{\\|y^{[j]} - y^{[j-1]}\\| + \\|y^{[j+1]} - y^{[j]}\\|}\n * \\f}\n *\n * \\param[in] yPrev a Vector denoting previous iterate of \\f$ y \\f$.\n * \\param[in] yCurrent a Vector denoting current iterate of \\f$ y \\f$.\n * \\param[in] yNext a Vector denoting next iterate of \\f$ y \\f$ as obtained from SDC iteration step.\n * \\param[in] norm an object of abstract base class type Norm, where we can provide the specific norm we consider for a problem.\n *\n * \\return \\f$ \\rho \\f$ an estimate of the SDC contraction factor. Return type is Vector::field_type\n */\n field_type sdcContractionFactor(std::vector const& yPrev,\n std::vector const& yCurrent,\n std::vector const& yNext,\n Norm& norm);\n\n //pure virtual functions\n /**\n * \\ingroup eulerSDC\n * The function definition changes with the associated norm. For derivation details for the vectors \\f$ \\alpha \\f$\n * and \\f$ \\Gamma \\f$ see M. Weiser, S. Ghosh: Adaptive inexact SDC Methods.\n * The vector \\f$ \\alpha \\f$ is given by \\f$ \\alpha = \\{\\alpha_1, \\ldots , \\alpha_N \\}\\f$, where\n * \\f{eqnarray*}{\n * \\alpha_i & = & \\sum_{k=1}^N |S_{ki}| + (1 - \\delta_{i,N})\\,(t_{i+1} - t_i)\\,(1 + \\rho),\n * \\f}\n * this is computed in case of \\f$ 1\\f$-norm and in the case of \\f$ \\max\\f$-norm we have\n * \\f$ \\Gamma = \\{\\Gamma_1, \\ldots, \\Gamma_N \\} \\f$, where\n * \\f{eqnarray*}{\n * \\Gamma_i & = & \\max_{1\\leq n \\leq N} \\alpha_{n,i}, \\textrm{ such that } \\\\\n * \\alpha_{n,i} & = & |S_{ni}| + \\delta_{i,n-1}\\,(t_i - t_{i-1})\\,(1+\\rho)\n * \\f}\n * @param[in] timePoints : Time points generated using the points() method of SDCTimeGrid.\n * @param[in] integrationMatrix : Integration matrix generated using the integrationMatrix() method of SDCTimeGrid.\n * Computed once for a given time grid.\n * @param[in] yPrev : Estimate of exact solution \\f$ y \\f$ using SDC iteration step\n * @param[in] yCurrent : The following estimate of \\f$ y \\f$ using SDC iteration step\n * @param[in] yNext : The next estimate of \\f$ y \\f$ after yCurrent using SDC iteration step\n *\n * \\return Reference to a Vector, where the vector is \\f$ \\alpha \\f$ or \\f$ \\Gamma \\f$ depending on the norm.\n */\n\n virtual RealVector const& computeAlphaVec(RealVector const& timePoints,\n RealMatrix const& integrationMatrix,\n std::vector const& yPrev,\n std::vector const& yCurrent,\n std::vector const& yNext) = 0;\n\n\n //virtual destructor\n virtual ~SDCUtil(){}\n };\n\n //===================================================================================================\n // Implementation of the derived class SDCUtilOneNorm w.r.t. 1-norm.\n //===================================================================================================\n template\n class SDCUtilOneNorm : public SDCUtil\n {\n public:\n using field_type = typename Vector::value_type;\n using RealVector = Dune::DynamicVector;\n using RealMatrix = Dune::DynamicMatrix;\n\n /**\n *\n * @param timePts : Represents a vector of time points\n * @param integrationMatrix\n * @param yPrev\n * @param yCurrent\n * @param yNext\n * @return\n */\n\n virtual RealVector const& computeAlphaVec(RealVector const& timePts,\n RealMatrix const& integrationMatrix,\n std::vector const& yPrev,\n std::vector const& yCurrent,\n std::vector const& yNext)\n {\n //number of collocation points\n auto nCollocationPts = timePts.size();\n alphaVec = RealVector(nCollocationPts-1, 0.0);\n\n //create one norm object\n Kaskade::OneNorm on;\n //compute sdc contraction rate\n auto rho = Kaskade::SDCUtil::sdcContractionFactor(yPrev, yCurrent, yNext, on);\n for (auto i = 0u; i < nCollocationPts-1; ++i)\n {\n field_type total = 0.0;\n for (auto k = 0u; k < nCollocationPts-1; ++k)\n total += std::abs(integrationMatrix[k][i]);\n if (i != nCollocationPts-2)\n alphaVec[i] = (total + (timePts[i+1] - timePts[i]) * (1 + rho));\n else\n alphaVec[i] = total;\n }\n return alphaVec;\n }\n\n\n virtual ~SDCUtilOneNorm(){}\n\n private:\n RealVector alphaVec;\n RealMatrix alphaMat;\n };\n\n //===================================================================================================\n // Implementation of the derived class SDCUtilMaxNorm w.r.t. max-norm.\n //===================================================================================================\n template\n class SDCUtilMaxNorm : public SDCUtil\n {\n public:\n using field_type = typename Vector::value_type;\n using RealVector = Dune::DynamicVector;\n using RealMatrix = Dune::DynamicMatrix;\n\n\n //TODO: Doc me\n /**\n *\n * @param timePts\n * @param integrationMatrix\n * @param yPrev\n * @param yCurrent\n * @param yNext\n * @return\n */\n virtual RealVector const& computeAlphaVec(RealVector const& timePts,\n RealMatrix const& integrationMatrix,\n std::vector const& yPrev,\n std::vector const& yCurrent,\n std::vector const& yNext)\n {\n //number of collocation points.\n auto nCollocationPts = timePts.size();\n gamma = RealVector(nCollocationPts, 0.0);\n\n //initialize the matrix alpha with size (nCollocationPts - 1) x nCollocationPts\n auto alphaMat = computeAlphaMat(timePts, integrationMatrix, yPrev, yCurrent, yNext, nCollocationPts);\n //Compute the vector Gamma.\n for (int i = 0; i < nCollocationPts -1; ++i)\n {\n for (int j = 0; j < nCollocationPts; ++j)\n {\n if (alphaMat[i][j] > gamma[j])\n gamma[j] = alphaMat[i][j];\n }\n }\n return gamma;\n }\n\n\n\n virtual ~SDCUtilMaxNorm() {};\n private:\n RealVector gamma;\n RealMatrix alphaMat;\n\n /**\n *\n * @param timePts\n * @param integrationMatrix\n * @param yPrev\n * @param yCurrent\n * @param yNext\n * @param nCollocationPts\n * @return\n */\n RealMatrix const& computeAlphaMat(RealVector const& timePts,\n RealMatrix const& integrationMatrix,\n std::vector const& yPrev,\n std::vector const& yCurrent,\n std::vector const& yNext,\n int nCollocationPts);\n\n\n };\n\n\n //=================================================================================================\n // FUNCTION DEFINITION BEGINS FROM HERE\n //=================================================================================================\n\n //=================================================================================================\n // Utility function to find norm of a difference of vector of two Vectors\n //=================================================================================================\n\n template\n typename Vector::value_type normVecDiff(std::vector const& y0, std::vector const& y1, Norm norm)\n {\n //Initialize the all the entries of dy to 0.0\n std::vector dy(y0.size(), Vector(0.0));\n for (auto i = 0u; i < y0.size(); ++i)\n {\n dy[i] = y1[i] - y0[i];\n }\n return norm.value(dy);\n }\n\n //===================================================================================================\n // Implementation of the abstract base class SDCUtil for all utility methods depending on the norms.\n //===================================================================================================\n\n template \n typename Vector::value_type SDCUtil::sdcContractionFactor(std::vector const& yPrev,\n std::vector const& yCurrent,\n std::vector const& yNext,\n Norm& norm)\n {\n size_t n = yPrev.size();\n //Compute the differences: yPrev - yCurrent and yCurrent - yNext\n std::vector y01(n, Vector(0.0));\n std::vector y12(n, Vector(0.0));\n for (auto i = 0u; i < n; ++i)\n {\n y01[i] = yCurrent[i] - yPrev[i] ;\n y12[i] = yNext[i] - yCurrent[i];\n }\n auto val01 = norm.value(y01);\n auto val12 = norm.value(y12);\n auto beta = val12/(val01 + val12);\n auto val = val12/val01;\n if (val > 1 || val != val) //check if val > 1 or val is NaN.\n {\n if (beta != beta) //check if beta = NaN\n val = 0.70;\n else\n val = beta;\n }\n return val;\n }\n\n\n //===================================================================================================\n // Implementation of the private method computeAlphaMat for the derived class SDCUtilMaxNorm\n //===================================================================================================\n using RealVector = Dune::DynamicVector;\n using RealMatrix = Dune::DynamicMatrix;\n\n template\n RealMatrix const& SDCUtilMaxNorm::computeAlphaMat(RealVector const& timePts,\n RealMatrix const& integrationMatrix,\n std::vector const& yPrev,\n std::vector const& yCurrent,\n std::vector const& yNext,\n int nCollocationPts)\n {\n //create max norm object\n Kaskade::MaxNorm mn;\n //compute sdc contraction rate\n auto rho = Kaskade::SDCUtil::sdcContractionFactor(yPrev, yCurrent, yNext, mn);\n alphaMat = RealMatrix(nCollocationPts-1, nCollocationPts, 0.0);\n for (auto i = 0; i < nCollocationPts-1; ++i)\n {\n for (auto k = 0; k < nCollocationPts; ++k)\n {\n if (i == k)\n alphaMat[i][k] = std::abs(integrationMatrix[i][k]) + (timePts[i+1] - timePts[i]) * (1 + rho);\n else\n alphaMat[i][k] = std::abs(integrationMatrix[i][k]);\n }\n }\n return alphaMat;\n }\n\n\n}//end namespace Kaskade\n\n\n\n\n#endif /* KASKADE_TIMESTEPPING_EULERSDC_UTIL_HH_ */\n", "meta": {"hexsha": "c539733e0e99e5fc9e899fa71bf13e1061faabfb", "size": 22743, "ext": "hh", "lang": "C++", "max_stars_repo_path": "Kaskade/timestepping/eulerSDC/util.hh", "max_stars_repo_name": "chenzongxiong/streambox", "max_stars_repo_head_hexsha": "76f95780d1bf6c02731e39d8ac73937cea352b95", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2019-07-03T14:03:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-19T10:18:49.000Z", "max_issues_repo_path": "Kaskade/timestepping/eulerSDC/util.hh", "max_issues_repo_name": "chenzongxiong/streambox", "max_issues_repo_head_hexsha": "76f95780d1bf6c02731e39d8ac73937cea352b95", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2020-02-17T12:01:30.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-09T22:02:33.000Z", "max_forks_repo_path": "Kaskade/timestepping/eulerSDC/util.hh", "max_forks_repo_name": "chenzongxiong/streambox", "max_forks_repo_head_hexsha": "76f95780d1bf6c02731e39d8ac73937cea352b95", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-12-03T04:41:18.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-11T21:44:42.000Z", "avg_line_length": 42.5898876404, "max_line_length": 173, "alphanum_fraction": 0.4932946401, "num_tokens": 5821, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7154239957834733, "lm_q2_score": 0.6959583313396339, "lm_q1q2_score": 0.49790529030579933}} {"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_TRIGONOMETRIC_FUNCTIONS_SCALAR_REM_PIO2_MEDIUM_HPP_INCLUDED\n#define NT2_TOOLBOX_TRIGONOMETRIC_FUNCTIONS_SCALAR_REM_PIO2_MEDIUM_HPP_INCLUDED\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace nt2 { namespace ext\n{\n NT2_FUNCTOR_IMPLEMENTATION(nt2::tag::rem_pio2_medium_, tag::cpu_,\n (A0),\n (scalar_ < floating_ > )\n )\n {\n typedef boost::fusion::tuple result_type;\n\n inline result_type operator()(A0 const& a0) const\n {\n result_type res;\n boost::fusion::at_c<2>(res) =\n nt2::rem_pio2_medium(a0,\n boost::fusion::at_c<0>(res),\n boost::fusion::at_c<1>(res)\n );\n return res;\n }\n };\n\n /////////////////////////////////////////////////////////////////////////////\n // reference based Implementation when real\n /////////////////////////////////////////////////////////////////////////////\n NT2_FUNCTOR_IMPLEMENTATION(nt2::tag::rem_pio2_medium_, tag::cpu_,\n (A0),\n (scalar_ < floating_ > )\n (scalar_ < floating_ > )\n (scalar_ < floating_ > )\n )\n {\n typedef typename meta::as_integer::type result_type;\n inline result_type operator()(A0 const& t, A0 & xr, A0& xc) const\n {\n const A0 fn = nt2::round(t*Invpio_2());\n A0 r = t-fn*Pio2_1();\n A0 w = fn*Pio2_1t();\n A0 t2 = r;\n w = fn*Pio2_2();\n r = t2-w;\n w = fn*Pio2_2t()-((t2-r)-w);\n t2 = r;\n w = fn*Pio2_3();\n r = t2-w;\n w = fn*Pio2_3t()-((t2-r)-w);\n xr = r-w;\n xc = (r-xr)-w;\n return fast_toint(fn)&3;\n }\n };\n} }\n#endif\n", "meta": {"hexsha": "89be380b193ec980466398a6c3d63c2ccface1fd", "size": 2648, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "modules/core/trigonometric/include/nt2/toolbox/trigonometric/functions/scalar/rem_pio2_medium.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/trigonometric/include/nt2/toolbox/trigonometric/functions/scalar/rem_pio2_medium.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/trigonometric/include/nt2/toolbox/trigonometric/functions/scalar/rem_pio2_medium.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": 37.8285714286, "max_line_length": 80, "alphanum_fraction": 0.4856495468, "num_tokens": 684, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303285397349, "lm_q2_score": 0.6297746213017459, "lm_q1q2_score": 0.4978559382836563}} {"text": "#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \"MODI.hpp\"\n#include \"Helper.hpp\"\n\nnamespace ublas = boost::numeric::ublas;\nusing namespace std;\n\nnamespace t_simplex\n{\n\t/**********************\n\tVogel's initialization method\n\t**********************/\n\tvoid _initVogel(\n\t\tvector &bi,\n\t\tvector dj,\n\t\tTsBasic * basicsEnd,\n\t\tTsBasic ** facBasics,\n\t\tTsBasic ** cusBasics,\n\t\tbool ** isBasic,\n\t\tint m,\n\t\tint n,\n\t\tublas::matrix &cij,\n\t\tdouble &_tsMaxW)\n\t{\n\t\tint i, j;\n\t\tTsVogPen *srcPens = NULL;\n\t\tTsVogPen *snkPens = NULL;\n\t\tTsVogPen *pitra = NULL, *pitrb = NULL; //iterators\n\t\tTsVogPen *maxPen = NULL;\n\t\tTsVogPen srcPenHead, snkPenHead;\n\t\tbool maxIsSrc = false;\n\t\tdouble lowVal = 0.0;\n\n\t\ttry\n\t\t{\n\t\t\tsrcPens = new TsVogPen[m];\n\t\t\tsnkPens = new TsVogPen[n];\n\t\t}\n\t\tcatch (std::bad_alloc)\n\t\t{\n\t\t\tdelete[] srcPens;\n\t\t\tdelete[] snkPens;\n\t\t\tthrow;\n\t\t}\n\n\t\tsrcPenHead.next = pitra = srcPens;\n\t\tfor (i = 0; i < m; i++)\n\t\t{\n\t\t\tpitra->i = i;\n\t\t\tpitra->next = pitra + 1;\n\t\t\tpitra->prev = pitra - 1;\n\t\t\tpitra->one = pitra->two = 0;\n\t\t\tpitra->oneCost = pitra->twoCost = TSINFINITY;\n\t\t\tpitra++;\n\t\t}\n\t\t(--pitra)->next = NULL;\n\t\tsrcPens[0].prev = &srcPenHead;\n\n\t\tsnkPenHead.next = pitra = snkPens;\n\t\tfor (i = 0; i < n; i++)\n\t\t{\n\t\t\tpitra->i = i;\n\t\t\tpitra->next = pitra + 1;\n\t\t\tpitra->prev = pitra - 1;\n\t\t\tpitra->one = pitra->two = 0;\n\t\t\tpitra->oneCost = pitra->twoCost = TSINFINITY;\n\t\t\tpitra++;\n\t\t}\n\t\t(--pitra)->next = NULL;\n\t\tsnkPens[0].prev = &snkPenHead;\n\n\n\t\tfor (pitra = srcPenHead.next, i = 0; pitra != NULL; pitra = pitra->next, i++)\n\t\t{\n\t\t\tfor (pitrb = snkPenHead.next, j = 0; pitrb != NULL; pitrb = pitrb->next, j++)\n\t\t\t{\n\t\t\t\t//initialize Source Penalties;\n\t\t\t\taddPenalty(pitra, cij(i, j), j);\n\t\t\t\taddPenalty(pitrb, cij(i, j), i);\n\t\t\t}\n\t\t}\n\n\t\twhile (srcPenHead.next != NULL && snkPenHead.next != NULL)\n\t\t{\n\t\t\tmaxIsSrc = true;\n\t\t\tfor (maxPen = pitra = srcPenHead.next; pitra != NULL; pitra = pitra->next)\n\t\t\t\tif ((pitra->twoCost - pitra->oneCost) > (maxPen->twoCost - maxPen->oneCost))\n\t\t\t\t\tmaxPen = pitra;\n\n\t\t\tfor (pitra = snkPenHead.next; pitra != NULL; pitra = pitra->next)\n\t\t\t\tif ((pitra->twoCost - pitra->oneCost) > (maxPen->twoCost - maxPen->oneCost))\n\t\t\t\t{\n\t\t\t\t\tmaxPen = pitra;\n\t\t\t\t\tmaxIsSrc = false;\n\t\t\t\t}\n\n\t\t\tif (maxIsSrc)\n\t\t\t{\n\t\t\t\ti = maxPen->i;\n\t\t\t\tj = maxPen->one;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tj = maxPen->i;\n\t\t\t\ti = maxPen->one;\n\t\t\t}\n\n\t\t\tif (dj[j] - bi[i] > _tsMaxW * TSEPSILON \n\t\t\t\t|| (srcPenHead.next->next != NULL\n\t\t\t\t&& fabs(dj[i] - bi[j]) < _tsMaxW * TSEPSILON))\n\t\t\t{\n\t\t\t\t//delete source\n\t\t\t\tlowVal = bi[i];\n\t\t\t\tmaxPen = srcPens + i;\n\t\t\t\tmaxPen->prev->next = maxPen->next;\n\t\t\t\tif (maxPen->next != NULL)\n\t\t\t\t\tmaxPen->next->prev = maxPen->prev;\n\n\t\t\t\tfor (pitra = snkPenHead.next; pitra != NULL; pitra = pitra->next)\n\t\t\t\t{\n\t\t\t\t\tif (pitra->one == i || pitra->two == i)\n\t\t\t\t\t{\n\t\t\t\t\t\tpitra->oneCost = TSINFINITY;\n\t\t\t\t\t\tpitra->twoCost = TSINFINITY;\n\t\t\t\t\t\tfor (pitrb = srcPenHead.next; pitrb != NULL; pitrb = pitrb->next)\n\t\t\t\t\t\t\taddPenalty(pitra, cij(pitrb->i, pitra->i), pitrb->i);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t//delete sink\n\t\t\t\tlowVal = dj[j];\n\t\t\t\tmaxPen = snkPens + j;\n\t\t\t\tmaxPen->prev->next = maxPen->next;\n\t\t\t\tif (maxPen->next != NULL)\n\t\t\t\t\tmaxPen->next->prev = maxPen->prev;\n\n\t\t\t\tfor (pitra = srcPenHead.next; pitra != NULL; pitra = pitra->next)\n\t\t\t\t{\n\t\t\t\t\tif (pitra->one == j || pitra->two == j) {\n\t\t\t\t\t\tpitra->oneCost = TSINFINITY;\n\t\t\t\t\t\tpitra->twoCost = TSINFINITY;\n\t\t\t\t\t\tfor (pitrb = snkPenHead.next; pitrb != NULL; pitrb = pitrb->next)\n\t\t\t\t\t\t\taddPenalty(pitra, cij(pitra->i, pitrb->i), pitrb->i);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tbi[i] -= lowVal;\n\t\t\tdj[j] -= lowVal;\n\n\t\t\tisBasic[i][j] = 1;\n\t\t\tbasicsEnd->val = lowVal;\n\t\t\tbasicsEnd->i = i;\n\t\t\tbasicsEnd->j = j;\n\n\t\t\tbasicsEnd->nextCus = cusBasics[j];\n\t\t\tif (cusBasics[j] != NULL) cusBasics[j]->prevCus = basicsEnd;\n\t\t\tbasicsEnd->nextFac = facBasics[i];\n\t\t\tif (facBasics[i] != NULL) facBasics[i]->prevFac = basicsEnd;\n\n\t\t\tfacBasics[i] = basicsEnd;\n\t\t\tbasicsEnd->prevCus = NULL;\n\t\t\tcusBasics[j] = basicsEnd;\n\t\t\tbasicsEnd->prevFac = NULL;\n\n\t\t\tbasicsEnd++;\n\t\t}\n\n\t\tdelete[] srcPens;\n\t\tsrcPens = NULL;\n\t\tdelete[] snkPens;\n\t\tsnkPens = NULL;\n\t}\n\n\t/**********************\n\tNW-Corner initialization method\n\t**********************/\n\tvoid _initNW(\n\t\tdouble *bi,\n\t\tdouble *dj,\n\t\tTsBasic * basicsEnd,\n\t\tTsBasic ** facBasics,\n\t\tTsBasic ** cusBasics,\n\t\tbool ** isBasic,\n\t\tint m,\n\t\tint n)\n\t{\n\t\tunsigned int i = 0, j = 0;\n\t\tdouble lowVal = 0.0;\n\n\t\twhile (i < m && j < n)\n\t\t{\n\t\t\t// More capacity than Demand\n\t\t\tif (bi[i] >= dj[j] && dj[j] != 0.0)\n\t\t\t{\n\t\t\t\tlowVal = dj[j];\n\t\t\t\tbi[i] -= dj[j];\n\t\t\t\tdj[j] = 0.0;\n\n\t\t\t\tisBasic[i][j] = 1;\n\t\t\t\tbasicsEnd->val = lowVal;\n\t\t\t\tbasicsEnd->i = i;\n\t\t\t\tbasicsEnd->j = j;\n\n\t\t\t\tbasicsEnd->nextCus = cusBasics[j];\n\t\t\t\tif (cusBasics[j] != NULL) cusBasics[j]->prevCus = basicsEnd;\n\t\t\t\tbasicsEnd->nextFac = facBasics[i];\n\t\t\t\tif (facBasics[i] != NULL) facBasics[i]->prevFac = basicsEnd;\n\n\t\t\t\tfacBasics[i] = basicsEnd;\n\t\t\t\tbasicsEnd->prevCus = NULL;\n\t\t\t\tcusBasics[j] = basicsEnd;\n\t\t\t\tbasicsEnd->prevFac = NULL;\n\n\t\t\t\tbasicsEnd++;\n\n\t\t\t\t// Test on Degeneration\n\t\t\t\tif (bi[i] == 0.0 && dj[j] == 0.0 && i < m - 1 && j < n - 1)\n\t\t\t\t{\n\t\t\t\t\tisBasic[i][j + 1] = 1;\n\t\t\t\t\tbasicsEnd->val = lowVal;\n\t\t\t\t\tbasicsEnd->i = i;\n\t\t\t\t\tbasicsEnd->j = j + 1;\n\n\t\t\t\t\tbasicsEnd->nextCus = cusBasics[j + 1];\n\t\t\t\t\tif (cusBasics[j + 1] != NULL) cusBasics[j + 1]->prevCus = basicsEnd;\n\t\t\t\t\tbasicsEnd->nextFac = facBasics[i];\n\t\t\t\t\tif (facBasics[i] != NULL) facBasics[i]->prevFac = basicsEnd;\n\n\t\t\t\t\tfacBasics[i] = basicsEnd;\n\t\t\t\t\tbasicsEnd->prevCus = NULL;\n\t\t\t\t\tcusBasics[j + 1] = basicsEnd;\n\t\t\t\t\tbasicsEnd->prevFac = NULL;\n\n\t\t\t\t\tbasicsEnd++;\n\n\t\t\t\t\ti++;\n\t\t\t\t\tj++;\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\t// Skip to next Customer\n\t\t\t\t\tj++;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Less Capacity than Demand\n\t\t\telse if (bi[i] < dj[j] && bi[i] != 0.0)\n\t\t\t{\n\t\t\t\tlowVal = bi[i];\n\t\t\t\tdj[j] -= bi[i];\n\t\t\t\tbi[i] = 0.0;\n\n\t\t\t\tisBasic[i][j] = 1;\n\t\t\t\tbasicsEnd->val = lowVal;\n\t\t\t\tbasicsEnd->i = i;\n\t\t\t\tbasicsEnd->j = j;\n\n\t\t\t\tbasicsEnd->nextCus = cusBasics[j];\n\t\t\t\tif (cusBasics[j] != NULL) cusBasics[j]->prevCus = basicsEnd;\n\t\t\t\tbasicsEnd->nextFac = facBasics[i];\n\t\t\t\tif (facBasics[i] != NULL) facBasics[i]->prevFac = basicsEnd;\n\n\t\t\t\tfacBasics[i] = basicsEnd;\n\t\t\t\tbasicsEnd->prevCus = NULL;\n\t\t\t\tcusBasics[j] = basicsEnd;\n\t\t\t\tbasicsEnd->prevFac = NULL;\n\n\t\t\t\tbasicsEnd++;\n\n\t\t\t\t// Test on Degeneration\n\t\t\t\tif (bi[i] == 0.0 && dj[j] == 0.0 && i < m - 1 && j < n - 1)\n\t\t\t\t{\n\t\t\t\t\tisBasic[i][j+1] = 1;\n\t\t\t\t\tbasicsEnd->val = lowVal;\n\t\t\t\t\tbasicsEnd->i = i;\n\t\t\t\t\tbasicsEnd->j = j+1;\n\n\t\t\t\t\tbasicsEnd->nextCus = cusBasics[j+1];\n\t\t\t\t\tif (cusBasics[j+1] != NULL) cusBasics[j+1]->prevCus = basicsEnd;\n\t\t\t\t\tbasicsEnd->nextFac = facBasics[i];\n\t\t\t\t\tif (facBasics[i] != NULL) facBasics[i]->prevFac = basicsEnd;\n\n\t\t\t\t\tfacBasics[i] = basicsEnd;\n\t\t\t\t\tbasicsEnd->prevCus = NULL;\n\t\t\t\t\tcusBasics[j+1] = basicsEnd;\n\t\t\t\t\tbasicsEnd->prevFac = NULL;\n\n\t\t\t\t\tbasicsEnd++;\n\n\t\t\t\t\ti++;\n\t\t\t\t\tj++;\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\t// Skip to next Customer\n\t\t\t\t\ti++;\n\t\t\t\t}\n\n\t\t\t}\n\t\t}\n\t}\n\n\t/**********************\n\tLCM initialization method\n\t**********************/\n\tvoid _initLCM(\n\t\tdouble *bi,\n\t\tdouble *dj,\n\t\tTsBasic *basicsEnd,\n\t\tTsBasic **facBasics,\n\t\tTsBasic **cusBasics,\n\t\tbool ** isBasic,\n\t\tint m,\n\t\tint n,\n\t\tublas::matrix &cij_column_sorted,\n\t\tint *facilities)\n\t{\n\t\tunsigned int i = 0, j = 0;\n\t\tunsigned int indx_i = 0;\n\t\tdouble lowVal = 0.0;\n\n\t\twhile (j < cij_column_sorted.size2())\n\t\t{\n\t\t\tindx_i = cij_column_sorted(i, j);\n\n\t\t\t// Can shift Capacity to fullfill Customer Demand\n\t\t\tif (bi[indx_i] != 0.0 && dj[j] != 0.0)\n\t\t\t{\n\t\t\t\t// More capacity than Demand\n\t\t\t\tif (bi[i] >= dj[j] && dj[j] != 0.0)\n\t\t\t\t{\n\t\t\t\t\tlowVal = dj[j];\n\t\t\t\t\tbi[i] -= dj[j];\n\t\t\t\t\tdj[j] = 0.0;\n\n\t\t\t\t\tisBasic[i][j] = 1;\n\t\t\t\t\tbasicsEnd->val = lowVal;\n\t\t\t\t\tbasicsEnd->i = i;\n\t\t\t\t\tbasicsEnd->j = j;\n\n\t\t\t\t\tbasicsEnd->nextCus = cusBasics[j];\n\t\t\t\t\tif (cusBasics[j] != NULL) cusBasics[j]->prevCus = basicsEnd;\n\t\t\t\t\tbasicsEnd->nextFac = facBasics[i];\n\t\t\t\t\tif (facBasics[i] != NULL) facBasics[i]->prevFac = basicsEnd;\n\n\t\t\t\t\tfacBasics[i] = basicsEnd;\n\t\t\t\t\tbasicsEnd->prevCus = NULL;\n\t\t\t\t\tcusBasics[j] = basicsEnd;\n\t\t\t\t\tbasicsEnd->prevFac = NULL;\n\n\t\t\t\t\tbasicsEnd++;\n\n\t\t\t\t\t// Skip to next Customer\n\t\t\t\t\tj++;\n\t\t\t\t\ti = 0;\n\t\t\t\t}\n\t\t\t\t// Less Capacity than Demand\n\t\t\t\telse if (bi[i] < dj[j] && bi[i] != 0.0)\n\t\t\t\t{\n\t\t\t\t\tlowVal = bi[i];\n\t\t\t\t\tdj[j] -= bi[i];\n\t\t\t\t\tbi[i] = 0.0;\n\n\t\t\t\t\tisBasic[i][j] = 1;\n\t\t\t\t\tbasicsEnd->val = lowVal;\n\t\t\t\t\tbasicsEnd->i = i;\n\t\t\t\t\tbasicsEnd->j = j;\n\n\t\t\t\t\tbasicsEnd->nextCus = cusBasics[j];\n\t\t\t\t\tif (cusBasics[j] != NULL) cusBasics[j]->prevCus = basicsEnd;\n\t\t\t\t\tbasicsEnd->nextFac = facBasics[i];\n\t\t\t\t\tif (facBasics[i] != NULL) facBasics[i]->prevFac = basicsEnd;\n\n\t\t\t\t\tfacBasics[i] = basicsEnd;\n\t\t\t\t\tbasicsEnd->prevCus = NULL;\n\t\t\t\t\tcusBasics[j] = basicsEnd;\n\t\t\t\t\tbasicsEnd->prevFac = NULL;\n\n\t\t\t\t\tbasicsEnd++;\n\n\t\t\t\t\t// Skip to next Customer\n\t\t\t\t\ti++;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// If its in the fictional Column\n\t\tif (n > cij_column_sorted.size2() && j == cij_column_sorted.size2())\n\t\t{\n\t\t\tfor (i = 0; i != cij_column_sorted.size1(); ++i)\n\t\t\t{\n\t\t\t\t// If Capacity is not empty ship to customer\n\t\t\t\tif (bi[i] != 0.0)\n\t\t\t\t{\n\t\t\t\t\tlowVal = bi[i];\n\t\t\t\t\tbi[i] = 0.0;\n\t\t\t\t\t\n\t\t\t\t\tisBasic[i][j] = 1;\n\t\t\t\t\tbasicsEnd->val = lowVal;\n\t\t\t\t\tbasicsEnd->i = i;\n\t\t\t\t\tbasicsEnd->j = j;\n\n\t\t\t\t\tbasicsEnd->nextCus = cusBasics[j];\n\t\t\t\t\tif (cusBasics[j] != NULL) cusBasics[j]->prevCus = basicsEnd;\n\t\t\t\t\tbasicsEnd->nextFac = facBasics[i];\n\t\t\t\t\tif (facBasics[i] != NULL) facBasics[i]->prevFac = basicsEnd;\n\n\t\t\t\t\tfacBasics[i] = basicsEnd;\n\t\t\t\t\tbasicsEnd->prevCus = NULL;\n\t\t\t\t\tcusBasics[j] = basicsEnd;\n\t\t\t\t\tbasicsEnd->prevFac = NULL;\n\n\t\t\t\t\tbasicsEnd++;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}", "meta": {"hexsha": "252cf9cb6700493992921ee16d75e18072cb20cc", "size": 9749, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "VNS Implementierung/VNS Implementierung/InitialMODI.cpp", "max_stars_repo_name": "franneck94/Variable-Neighborhood-Search-FLP", "max_stars_repo_head_hexsha": "891cea0be1c3250cd9990eb35ef5701cb20bf964", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-10-05T08:26:52.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-05T08:26:52.000Z", "max_issues_repo_path": "VNS Implementierung/VNS Implementierung/InitialMODI.cpp", "max_issues_repo_name": "franneck94/Variable-Neighborhood-Search-FLP", "max_issues_repo_head_hexsha": "891cea0be1c3250cd9990eb35ef5701cb20bf964", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-05-28T09:54:53.000Z", "max_issues_repo_issues_event_max_datetime": "2018-05-28T09:54:53.000Z", "max_forks_repo_path": "VNS Implementierung/VNS Implementierung/InitialMODI.cpp", "max_forks_repo_name": "franneck94/Variable-Neighborhood-Search-FLP", "max_forks_repo_head_hexsha": "891cea0be1c3250cd9990eb35ef5701cb20bf964", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-10-05T08:26:59.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-02T09:21:54.000Z", "avg_line_length": 22.831381733, "max_line_length": 80, "alphanum_fraction": 0.5585188224, "num_tokens": 3586, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303087996143, "lm_q2_score": 0.6297746213017459, "lm_q1q2_score": 0.4978559258518293}} {"text": "#ifndef STAN_OPTIMIZATION_BFGS_LINESEARCH_HPP\r\n#define STAN_OPTIMIZATION_BFGS_LINESEARCH_HPP\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\nnamespace stan {\r\n namespace optimization {\r\n /**\r\n * Find the minima in an interval [loX, hiX] of a cubic function which\r\n * interpolates the points, function values and gradients provided.\r\n *\r\n * Implicitly, this function constructs an interpolating polynomial\r\n * g(x) = a_3 x^3 + a_2 x^2 + a_1 x + a_0\r\n * such that g(0) = 0, g(x1) = f1, g'(0) = df0, g'(x1) = df1 where\r\n * g'(x) = 3 a_3 x^2 + 2 a_2 x + a_1\r\n * is the derivative of g(x). It then computes the roots of g'(x) and\r\n * finds the minimal value of g(x) on the interval [loX,hiX] including\r\n * the end points.\r\n *\r\n * This function implements the full parameter version of CubicInterp().\r\n *\r\n * @param df0 First derivative value, f'(x0)\r\n * @param x1 Second point\r\n * @param f1 Second function value, f(x1)\r\n * @param df1 Second derivative value, f'(x1)\r\n * @param loX Lower bound on the interval of solutions\r\n * @param hiX Upper bound on the interval of solutions\r\n **/\r\n template\r\n Scalar CubicInterp(const Scalar &df0,\r\n const Scalar &x1, const Scalar &f1, const Scalar &df1,\r\n const Scalar &loX, const Scalar &hiX) {\r\n const Scalar c3((-12*f1 + 6*x1*(df0 + df1))/(x1*x1*x1));\r\n const Scalar c2(-(4*df0 + 2*df1)/x1 + 6*f1/(x1*x1));\r\n const Scalar &c1(df0);\r\n\r\n const Scalar t_s = std::sqrt(c2*c2 - 2.0*c1*c3);\r\n const Scalar s1 = - (c2 + t_s)/c3;\r\n const Scalar s2 = - (c2 - t_s)/c3;\r\n\r\n Scalar tmpF;\r\n Scalar minF, minX;\r\n\r\n // Check value at lower bound\r\n minF = loX*(loX*(loX*c3/3.0 + c2)/2.0 + c1);\r\n minX = loX;\r\n\r\n // Check value at upper bound\r\n tmpF = hiX*(hiX*(hiX*c3/3.0 + c2)/2.0 + c1);\r\n if (tmpF < minF) {\r\n minF = tmpF;\r\n minX = hiX;\r\n }\r\n\r\n // Check value of first root\r\n if (loX < s1 && s1 < hiX) {\r\n tmpF = s1*(s1*(s1*c3/3.0 + c2)/2.0 + c1);\r\n if (tmpF < minF) {\r\n minF = tmpF;\r\n minX = s1;\r\n }\r\n }\r\n\r\n // Check value of second root\r\n if (loX < s2 && s2 < hiX) {\r\n tmpF = s2*(s2*(s2*c3/3.0 + c2)/2.0 + c1);\r\n if (tmpF < minF) {\r\n minF = tmpF;\r\n minX = s2;\r\n }\r\n }\r\n\r\n return minX;\r\n }\r\n\r\n /**\r\n * Find the minima in an interval [loX, hiX] of a cubic function which\r\n * interpolates the points, function values and gradients provided.\r\n *\r\n * Implicitly, this function constructs an interpolating polynomial\r\n * g(x) = a_3 x^3 + a_2 x^2 + a_1 x + a_0\r\n * such that g(x0) = f0, g(x1) = f1, g'(x0) = df0, g'(x1) = df1 where\r\n * g'(x) = 3 a_3 x^2 + 2 a_2 x + a_1\r\n * is the derivative of g(x). It then computes the roots of g'(x) and\r\n * finds the minimal value of g(x) on the interval [loX,hiX] including\r\n * the end points.\r\n *\r\n * @param x0 First point\r\n * @param f0 First function value, f(x0)\r\n * @param df0 First derivative value, f'(x0)\r\n * @param x1 Second point\r\n * @param f1 Second function value, f(x1)\r\n * @param df1 Second derivative value, f'(x1)\r\n * @param loX Lower bound on the interval of solutions\r\n * @param hiX Upper bound on the interval of solutions\r\n **/\r\n template\r\n Scalar CubicInterp(const Scalar &x0, const Scalar &f0, const Scalar &df0,\r\n const Scalar &x1, const Scalar &f1, const Scalar &df1,\r\n const Scalar &loX, const Scalar &hiX) {\r\n return x0 + CubicInterp(df0, x1-x0, f1-f0, df1, loX-x0, hiX-x0);\r\n }\r\n\r\n /**\r\n * An internal utility function for implementing WolfeLineSearch()\r\n **/\r\n template\r\n int WolfLSZoom(Scalar &alpha, XType &newX, Scalar &newF, XType &newDF,\r\n FunctorType &func,\r\n const XType &x, const Scalar &f, const Scalar &dfp,\r\n const Scalar &c1dfp, const Scalar &c2dfp, const XType &p,\r\n Scalar alo, Scalar aloF, Scalar aloDFp,\r\n Scalar ahi, Scalar ahiF, Scalar ahiDFp,\r\n const Scalar &min_range) {\r\n Scalar d1, d2, newDFp;\r\n int itNum(0);\r\n\r\n while (1) {\r\n itNum++;\r\n\r\n if (std::fabs(alo-ahi) < min_range)\r\n return 1;\r\n\r\n if (itNum%5 == 0) {\r\n alpha = 0.5*(alo+ahi);\r\n } else {\r\n // Perform cubic interpolation to determine next point to try\r\n d1 = aloDFp + ahiDFp - 3*(aloF-ahiF)/(alo-ahi);\r\n d2 = std::sqrt(d1*d1 - aloDFp*ahiDFp);\r\n if (ahi < alo)\r\n d2 = -d2;\r\n alpha = ahi\r\n - (ahi - alo) * (ahiDFp + d2 - d1) / (ahiDFp - aloDFp + 2*d2);\r\n if (!boost::math::isfinite(alpha) ||\r\n alpha < std::min(alo, ahi) + 0.01 * std::fabs(alo - ahi) ||\r\n alpha > std::max(alo, ahi) - 0.01 * std::fabs(alo - ahi))\r\n alpha = 0.5 * (alo + ahi);\r\n }\r\n\r\n newX = x + alpha * p;\r\n while (func(newX, newF, newDF)) {\r\n alpha = 0.5 * (alpha + std::min(alo, ahi));\r\n if (std::fabs(std::min(alo, ahi) - alpha) < min_range)\r\n return 1;\r\n newX = x + alpha * p;\r\n }\r\n newDFp = newDF.dot(p);\r\n if (newF > (f + alpha * c1dfp) || newF >= aloF) {\r\n ahi = alpha;\r\n ahiF = newF;\r\n ahiDFp = newDFp;\r\n } else {\r\n if (std::fabs(newDFp) <= -c2dfp)\r\n break;\r\n if (newDFp*(ahi-alo) >= 0) {\r\n ahi = alo;\r\n ahiF = aloF;\r\n ahiDFp = aloDFp;\r\n }\r\n alo = alpha;\r\n aloF = newF;\r\n aloDFp = newDFp;\r\n }\r\n }\r\n return 0;\r\n }\r\n\r\n /**\r\n * Perform a line search which finds an approximate solution to:\r\n * \\f[\r\n * \\min_\\alpha f(x_0 + \\alpha p)\r\n * \\f]\r\n * satisfying the strong Wolfe conditions:\r\n * 1) \\f$ f(x_0 + \\alpha p) \\leq f(x_0) + c_1 \\alpha p^T g(x_0) \\f$\r\n * 2) \\f$ \\vert p^T g(x_0 + \\alpha p) \\vert \\leq c_2 \\vert p^T g(x_0) \\vert \\f$\r\n * where \\f$g(x) = \\frac{\\partial f}{\\partial x}\\f$ is the gradient of f(x).\r\n *\r\n * @tparam FunctorType A type which supports being called as\r\n * ret = func(x,f,g)\r\n * where x is the input point, f and g are the function value and\r\n * gradient at x and ret is non-zero if function evaluation fails.\r\n *\r\n * @param func Function which is being minimized.\r\n *\r\n * @param alpha First value of \\f$ \\alpha \\f$ to try. Upon return this\r\n * contains the final value of the \\f$ \\alpha \\f$.\r\n *\r\n * @param x1 Final point, equal to \\f$ x_0 + \\alpha p \\f$.\r\n *\r\n * @param f1 Final point function value, equal to \\f$ f(x_0 + \\alpha p) \\f$.\r\n *\r\n * @param gradx1 Final point gradient, equal to \\f$ g(x_0 + \\alpha p) \\f$.\r\n *\r\n * @param p Search direction. It is assumed to be a descent direction such\r\n * that \\f$ p^T g(x_0) < 0 \\f$.\r\n *\r\n * @param x0 Value of starting point, \\f$ x_0 \\f$.\r\n *\r\n * @param f0 Value of function at starting point, \\f$ f(x_0) \\f$.\r\n *\r\n * @param gradx0 Value of function gradient at starting point,\r\n * \\f$ g(x_0) \\f$.\r\n *\r\n * @param c1 Parameter of the Wolfe conditions. \\f$ 0 < c_1 < c_2 < 1 \\f$\r\n * Typically c1 = 1e-4.\r\n *\r\n * @param c2 Parameter of the Wolfe conditions. \\f$ 0 < c_1 < c_2 < 1 \\f$\r\n * Typically c2 = 0.9.\r\n *\r\n * @param minAlpha Smallest allowable step-size.\r\n *\r\n * @param maxLSIts Maximum number line search iterations.\r\n *\r\n * @param maxLSRestarts Maximum number of times line search will\r\n * restart with \\f$ f() \\f$ failing.\r\n *\r\n * @return Returns zero on success, non-zero otherwise.\r\n **/\r\n template\r\n int WolfeLineSearch(FunctorType &func,\r\n Scalar &alpha,\r\n XType &x1, Scalar &f1, XType &gradx1,\r\n const XType &p,\r\n const XType &x0, const Scalar &f0, const XType &gradx0,\r\n const Scalar &c1, const Scalar &c2,\r\n const Scalar &minAlpha, const Scalar &maxLSIts,\r\n const Scalar &maxLSRestarts) {\r\n const Scalar dfp(gradx0.dot(p));\r\n const Scalar c1dfp(c1*dfp);\r\n const Scalar c2dfp(c2*dfp);\r\n\r\n Scalar alpha0(minAlpha);\r\n Scalar alpha1(alpha);\r\n\r\n Scalar prevF(f0);\r\n XType prevDF(gradx0);\r\n Scalar prevDFp(dfp);\r\n Scalar newDFp;\r\n\r\n int retCode = 0, nits = 0, lsRestarts = 0, ret;\r\n\r\n while (1) {\r\n if (nits >= maxLSIts) {\r\n retCode = 1;\r\n break;\r\n }\r\n\r\n x1.noalias() = x0 + alpha1 * p;\r\n ret = func(x1, f1, gradx1);\r\n if (ret != 0) {\r\n if (lsRestarts >= maxLSRestarts) {\r\n retCode = 1;\r\n break;\r\n }\r\n\r\n alpha1 = 0.5 * (alpha0 + alpha1);\r\n lsRestarts++;\r\n continue;\r\n }\r\n lsRestarts = 0;\r\n\r\n newDFp = gradx1.dot(p);\r\n if ((f1 > f0 + alpha * c1dfp) || (f1 >= prevF && nits > 0)) {\r\n retCode = WolfLSZoom(alpha, x1, f1, gradx1,\r\n func,\r\n x0, f0, dfp,\r\n c1dfp, c2dfp, p,\r\n alpha0, prevF, prevDFp,\r\n alpha1, f1, newDFp,\r\n 1e-16);\r\n break;\r\n }\r\n if (std::fabs(newDFp) <= -c2dfp) {\r\n alpha = alpha1;\r\n break;\r\n }\r\n if (newDFp >= 0) {\r\n retCode = WolfLSZoom(alpha, x1, f1, gradx1,\r\n func,\r\n x0, f0, dfp,\r\n c1dfp, c2dfp, p,\r\n alpha1, f1, newDFp,\r\n alpha0, prevF, prevDFp,\r\n 1e-16);\r\n break;\r\n }\r\n\r\n alpha0 = alpha1;\r\n prevF = f1;\r\n std::swap(prevDF, gradx1);\r\n prevDFp = newDFp;\r\n\r\n alpha1 *= 10.0;\r\n\r\n nits++;\r\n }\r\n return retCode;\r\n }\r\n }\r\n}\r\n\r\n#endif\r\n", "meta": {"hexsha": "132e5a246f95499cca8424b50fbe002c73b00bdb", "size": 10648, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "archive/stan/src/stan/optimization/bfgs_linesearch.hpp", "max_stars_repo_name": "alashworth/stan-monorepo", "max_stars_repo_head_hexsha": "75596bc1f860ededd7b3e9ae9002aea97ee1cd46", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-09-06T15:53:17.000Z", "max_stars_repo_stars_event_max_datetime": "2019-09-06T15:53:17.000Z", "max_issues_repo_path": "archive/stan/src/stan/optimization/bfgs_linesearch.hpp", "max_issues_repo_name": "alashworth/stan-monorepo", "max_issues_repo_head_hexsha": "75596bc1f860ededd7b3e9ae9002aea97ee1cd46", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 8.0, "max_issues_repo_issues_event_min_datetime": "2019-01-17T18:51:16.000Z", "max_issues_repo_issues_event_max_datetime": "2019-01-17T18:51:39.000Z", "max_forks_repo_path": "archive/stan/src/stan/optimization/bfgs_linesearch.hpp", "max_forks_repo_name": "alashworth/stan-monorepo", "max_forks_repo_head_hexsha": "75596bc1f860ededd7b3e9ae9002aea97ee1cd46", "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": 34.5714285714, "max_line_length": 85, "alphanum_fraction": 0.4968069121, "num_tokens": 3187, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303186696747, "lm_q2_score": 0.6297746074044134, "lm_q1q2_score": 0.4978559210814802}} {"text": "//\n// Created by yanhang on 4/21/16.\n//\n\n#include \"warping.h\"\n#include \"gridenergy.h\"\n#include \"utility.h\"\n#include \n#include \n#include \n\nusing namespace std;\nusing namespace Eigen;\nusing namespace cv;\n\nnamespace substab{\n\n\tGridWarpping::GridWarpping(const int w, const int h, const int gw, const int gh) : width(w), height(h), gridW(gw), gridH(gh) {\n\t\tblockW = (double) width / gridW;\n\t\tblockH = (double) height / gridH;\n\t\tgridLoc.resize((size_t) (gridW + 1) * (gridH + 1));\n\t\tfor (auto x = 0; x <= gridW; ++x) {\n\t\t\tfor (auto y = 0; y <= gridH; ++y) {\n\t\t\t\tgridLoc[y * (gridW + 1) + x] = Eigen::Vector2d(blockW * x, blockH * y);\n\t\t\t\tif (x == gridW)\n\t\t\t\t\tgridLoc[y * (gridW + 1) + x][0] -= 1.1;\n\t\t\t\tif (y == gridH)\n\t\t\t\t\tgridLoc[y * (gridW + 1) + x][1] -= 1.1;\n\t\t\t}\n\t\t}\n\t}\n\n\tvoid GridWarpping::getGridIndAndWeight(const Eigen::Vector2d &pt, Eigen::Vector4i &ind,\n\t\t\t\t\t\t\t\t\t\t Eigen::Vector4d &w) const {\n\t\tCHECK_LE(pt[0], width - 1);\n\t\tCHECK_LE(pt[1], height - 1);\n\t\tint x = (int) floor(pt[0] / blockW);\n\t\tint y = (int) floor(pt[1] / blockH);\n\n\t\t//////////////\n\t\t// 1--2\n\t\t// | |\n\t\t// 4--3\n\t\t/////////////\n\t\tind = Vector4i(y * (gridW + 1) + x, y * (gridW + 1) + x + 1, (y + 1) * (gridW + 1) + x + 1,\n\t\t\t\t\t (y + 1) * (gridW + 1) + x);\n\n\t\tconst double &xd = pt[0];\n\t\tconst double &yd = pt[1];\n\t\tconst double xl = gridLoc[ind[0]][0];\n\t\tconst double xh = gridLoc[ind[2]][0];\n\t\tconst double yl = gridLoc[ind[0]][1];\n\t\tconst double yh = gridLoc[ind[2]][1];\n\n\t\tw[0] = (xh - xd) * (yh - yd);\n\t\tw[1] = (xd - xl) * (yh - yd);\n\t\tw[2] = (xd - xl) * (yd - yl);\n\t\tw[3] = (xh - xd) * (yd - yl);\n\n\t\tdouble s = w[0] + w[1] + w[2] + w[3];\n\t\tCHECK_GT(s, 0) << pt[0] << ' '<< pt[1];\n\t\tw = w / s;\n\n\t\tVector2d pt2 =\n\t\t\t\tgridLoc[ind[0]] * w[0] + gridLoc[ind[1]] * w[1] + gridLoc[ind[2]] * w[2] + gridLoc[ind[3]] * w[3];\n\t\tdouble error = (pt2 - pt).norm();\n\t\tCHECK_LT(error, 0.0001) << pt[0] << ' ' << pt[1] << ' ' << pt2[0] << ' ' << pt2[1];\n\t}\n\n\n\tvoid GridWarpping::visualizeGrid(const std::vector& grid, cv::Mat &img) const {\n\t\tCHECK_EQ(grid.size(), gridLoc.size());\n\t\tCHECK_EQ(img.cols, width);\n\t\tCHECK_EQ(img.rows, height);\n\t\t//img = Mat(height, width, CV_8UC3, Scalar(0,0,0));\n\t\tfor(auto gy=0; gy 0 && grid[gid2][0] > 0)\n\t\t\t\t\tcv::line(img, cv::Point(grid[gid1][0], grid[gid1][1]), cv::Point(grid[gid2][0], grid[gid2][1]), Scalar(255,255,255));\n\t\t\t\tif(grid[gid2][0] > 0 && grid[gid3][0] > 0)\n\t\t\t\t\tcv::line(img, cv::Point(grid[gid2][0], grid[gid2][1]), cv::Point(grid[gid3][0], grid[gid3][1]), Scalar(255,255,255));\n\t\t\t\tif(grid[gid3][0] > 0 && grid[gid4][0] > 0)\n\t\t\t\t\tcv::line(img, cv::Point(grid[gid3][0], grid[gid3][1]), cv::Point(grid[gid4][0], grid[gid4][1]), Scalar(255,255,255));\n\t\t\t\tif(grid[gid4][0] > 0 && grid[gid1][0] > 0)\n\t\t\t\t\tcv::line(img, cv::Point(grid[gid4][0], grid[gid4][1]), cv::Point(grid[gid1][0], grid[gid1][1]), Scalar(255,255,255));\n\t\t\t}\n\t\t}\n\t}\n\n\tvoid GridWarpping::computeSimilarityWeight(const cv::Mat &input, std::vector& saliency) const {\n\t\tsaliency.resize((size_t)(gridW*gridH));\n\t\tfor(auto y=0; y > pixs(3);\n\t\t\t\tfor(auto x1=(int)gridLoc[gridInd(x,y)][0]; x1(y1,x1);\n\t\t\t\t\t\tpixs[0].push_back((double)pix[0] / 255.0);\n\t\t\t\t\t\tpixs[1].push_back((double)pix[1] / 255.0);\n\t\t\t\t\t\tpixs[2].push_back((double)pix[2] / 255.0);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tVector3d vars(math_util::variance(pixs[0]),math_util::variance(pixs[1]),math_util::variance(pixs[2]));\n\t\t\t\tsaliency[gid] = vars.norm();\n\t\t\t}\n\t\t}\n\t}\n\n\n\tvoid GridWarpping::warpImageCloseForm(const cv::Mat &input, cv::Mat &output, const vector& pts1, const vector& pts2, const int id) const {\n\t\tCHECK_EQ(pts1.size(), pts2.size());\n\n\t\tchar buffer[1024] = {};\n\n\t\tvector resGrid(gridLoc.size());\n\t\tconst int kDataTerm = (int)pts1.size() * 2;\n\t\tconst int kSimTerm = (gridW-1)*(gridH-1)*8;\n\t\tconst int kVar = (int)gridLoc.size() * 2;\n\n\t\tvector > triplets;\n\t\tVectorXd B(kDataTerm+kSimTerm);\n\t\t//add data constraint\n\t\tconst double wdata = 1.0;\n\t\tconst double wsimilarity = 20;\n\t\tint cInd = 0;\n\t\tfor(auto i=0; i= width - 1 || pts2[i][1] >= height - 1)\n\t\t\t\tcontinue;\n\t\t\tVector4i indRef;\n\t\t\tVector4d bwRef;\n\t\t\tCHECK_LT(cInd + 1, B.rows());\n\n\t\t\tgetGridIndAndWeight(pts2[i], indRef, bwRef);\n\t\t\tfor (auto j = 0; j < 4; ++j) {\n\t\t\t\tCHECK_LT(indRef[j]*2+1, kVar);\n\t\t\t\ttriplets.push_back(Triplet(cInd, indRef[j] * 2, wdata * bwRef[j]));\n\t\t\t\ttriplets.push_back(Triplet(cInd + 1, indRef[j] * 2 + 1, wdata * bwRef[j]));\n\t\t\t}\n\t\t\tB[cInd] = wdata * pts1[i][0];\n\t\t\tB[cInd + 1] = wdata * pts1[i][1];\n\t\t\tcInd += 2;\n\t\t}\n\n\t\t// Mat inputOutput = input.clone();\n\t\t// visualizeGrid(gridLoc, inputOutput);\n\t\t// for(const auto& pt: pts1)\n\t\t// \tcv::circle(inputOutput, cv::Point2d(pt[0], pt[1]), 1, Scalar(0,0,255), 2);\n\t\t// sprintf(buffer, \"vis_input%05d.jpg\", id);\n\t\t// imwrite(buffer, inputOutput);\n\n//\t\tvector saliency;\n//\t\tcomputeSimilarityWeight(input, saliency);\n\n\t\tauto getLocalCoord = [](const Vector2d& p1, const Vector2d& p2, const Vector2d& p3){\n\t\t\tVector2d axis1 = p3 - p2;\n\t\t\tVector2d axis2(-1*axis1[1], axis1[0]);\n\t\t\tVector2d v = p1 - p2;\n\t\t\treturn Vector2d(v.dot(axis1)/axis1.squaredNorm(), v.dot(axis2)/axis2.squaredNorm());\n\t\t};\n\t\t{\n\t\t\t//test for local coord\n//\t\t\tVector2d p1(0,0), p2(0,-1), p3(1,0);\n//\t\t\tVector2d uv = getLocalCoord(p1,p2,p3);\n//\t\t\tprintf(\"(%.2f,%.2f)\\n\", uv[0], uv[1]);\n\t\t}\n\t\tfor(auto y=1; y< gridH; ++y) {\n\t\t\tfor (auto x = 1; x < gridW; ++x) {\n\t\t\t\tvector gids{\n\t\t\t\t\t\tVector2i(gridInd(x - 1, y), gridInd(x, y - 1)),\n\t\t\t\t\t\tVector2i(gridInd(x, y - 1), gridInd(x + 1, y)),\n\t\t\t\t\t\tVector2i(gridInd(x + 1, y), gridInd(x, y + 1)),\n\t\t\t\t\t\tVector2i(gridInd(x, y + 1), gridInd(x - 1, y))\n\t\t\t\t};\n\t\t\t\tconst int cgid = gridInd(x, y);\n//\t\t\t\tprintf(\"-----------------------\\n\");\n\t\t\t\tfor (const auto &gid: gids) {\n\t\t\t\t\tVector2d refUV = getLocalCoord(gridLoc[cgid], gridLoc[gid[0]], gridLoc[gid[1]]);\n//\t\t\t\t\tprintf(\"(%.2f,%.2f),(%.2f,%.2f),(%.2f,%.2f), u:%.2f,v:%.2f\\n\", gridLoc[cgid][0], gridLoc[cgid][1],\n//\t\t\t\t\t\t gridLoc[gid[0]][0], gridLoc[gid[0]][1], gridLoc[gid[1]][0], gridLoc[gid[1]][1], refUV[0],\n//\t\t\t\t\t\t refUV[1]);\n\t\t\t\t\t//x coordinate\n\t\t\t\t\ttriplets.push_back(Triplet(cInd, cgid * 2, wsimilarity));\n\t\t\t\t\ttriplets.push_back(Triplet(cInd, gid[0]*2, -1 * wsimilarity));\n\t\t\t\t\ttriplets.push_back(Triplet(cInd, gid[0] * 2, refUV[0] * wsimilarity));\n\t\t\t\t\ttriplets.push_back(Triplet(cInd, gid[1] * 2, -1 * refUV[0] * wsimilarity));\n\n\t\t\t\t\ttriplets.push_back(Triplet(cInd, gid[0] * 2 + 1, -1 * refUV[1] * wsimilarity));\n\t\t\t\t\ttriplets.push_back(Triplet(cInd, gid[1] * 2 + 1, refUV[1] * wsimilarity));\n\t\t\t\t\tB[cInd] = 0;\n\n\t\t\t\t\t//y coordinate\n\t\t\t\t\ttriplets.push_back(Triplet(cInd + 1, cgid * 2 + 1, wsimilarity));\n\t\t\t\t\ttriplets.push_back(Triplet(cInd + 1, gid[0] * 2 + 1, -1 * wsimilarity));\n\t\t\t\t\ttriplets.push_back(Triplet(cInd + 1, gid[0] * 2 + 1, refUV[0] * wsimilarity));\n\t\t\t\t\ttriplets.push_back(Triplet(cInd + 1, gid[1] * 2 + 1, -1 * refUV[0] * wsimilarity));\n\t\t\t\t\ttriplets.push_back(Triplet(cInd + 1, gid[0] * 2, refUV[1] * wsimilarity));\n\t\t\t\t\ttriplets.push_back(Triplet(cInd + 1, gid[1] * 2, -1 * refUV[1] * wsimilarity));\n\t\t\t\t\tB[cInd + 1] = 0;\n\t\t\t\t\tcInd += 2;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n//\t\tconst double wregular = 0.1;\n//\t\tfor(auto x=0; x<=gridW; ++x){\n//\t\t\tfor(auto y=0; y<=gridH; ++y){\n//\t\t\t\tint gid = gridInd(x,y);\n//\t\t\t\ttriplets.push_back(Triplet(cInd, gid*2, wregular));\n//\t\t\t\ttriplets.push_back(Triplet(cInd+1, gid*2+1, wregular));\n//\t\t\t\tB[cInd] = wregular * gridLoc[gid][0];\n//\t\t\t\tB[cInd+1] = wregular * gridLoc[gid][1];\n//\t\t\t\tcInd +=2;\n//\t\t\t}\n//\t\t}\n\t\tCHECK_LE(cInd, kDataTerm+kSimTerm);\n\t\tSparseMatrix A(cInd, kVar);\n\t\tA.setFromTriplets(triplets.begin(), triplets.end());\n\n\t\tEigen::SPQR > solver(A);\n\t\tVectorXd res = solver.solve(B.block(0,0,cInd,1));\n\t\tCHECK_EQ(res.rows(), kVar);\n\n\t\tvector vars(gridLoc.size());\n\t\tfor(auto i=0; i width - 1 || pt[1] > height - 1)\n\t\t\t\t\tcontinue;\n\t\t\t\tVector3d pixO = interpolation_util::bilinear(input.data, input.cols, input.rows, pt);\n\t\t\t\toutput.at(y,x) = Vec3b((uchar) pixO[0], (uchar)pixO[1], (uchar)pixO[2]);\n\t\t\t}\n\t\t}\n\n\t\t// Mat outputOutput = input.clone();\n\t\t// visualizeGrid(vars, outputOutput);\n\t\t// for(const auto& pt: pts2)\n\t\t// \tcv::circle(outputOutput, cv::Point2d(pt[0], pt[1]), 1, Scalar(0,0,255), 2);\n\t\t// sprintf(buffer, \"vis_output%05d.jpg\", id);\n\t\t// imwrite(buffer, outputOutput);\n\t}\n\n}//namespace substablas\n", "meta": {"hexsha": "739ac504279c9c704869fb443d3a7e13b5188f7c", "size": 9557, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "code/warping.cpp", "max_stars_repo_name": "ishank-juneja/SubspaceStab", "max_stars_repo_head_hexsha": "3c4ee8c001a7c4864870f30c880d389790500ea0", "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": "code/warping.cpp", "max_issues_repo_name": "ishank-juneja/SubspaceStab", "max_issues_repo_head_hexsha": "3c4ee8c001a7c4864870f30c880d389790500ea0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2021-05-29T17:19:37.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-12T17:03:13.000Z", "max_forks_repo_path": "code/warping.cpp", "max_forks_repo_name": "ishank-juneja/SubspaceStab", "max_forks_repo_head_hexsha": "3c4ee8c001a7c4864870f30c880d389790500ea0", "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.6168582375, "max_line_length": 159, "alphanum_fraction": 0.5770639322, "num_tokens": 3749, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303186696747, "lm_q2_score": 0.6297746074044134, "lm_q1q2_score": 0.4978559210814802}} {"text": "//============================================================================\n//\n// This file is part of the Thea toolkit.\n//\n// This software is distributed under the BSD license, as detailed in the\n// accompanying LICENSE.txt file. Portions are derived from other works:\n// their respective licenses and copyright information are reproduced in\n// LICENSE.txt and/or in the relevant source files.\n//\n// Author: Siddhartha Chaudhuri\n// First version: 2019\n//\n//============================================================================\n\n#ifndef __Thea_MatVec_hpp__\n#define __Thea_MatVec_hpp__\n\n#include \"Common.hpp\"\n#include \"MatrixFormat.hpp\"\n\n// Resolve a conflict between X.h (which #defines Success) and Eigen (which has an enum called Success). Fortunately both\n// headers currently assign the same value to Success (0) so the #undef should be all that's needed.\n// https://stackoverflow.com/questions/22400905/eigen-and-cimg-compatibility-issues\n#ifdef Success\n# undef Success\n#endif\n#include \n#include // for Quaternion, and because for some weird reason Eigen defines cross() here\n\n#include \n\nnamespace Thea {\n\n#ifdef THEA_ROW_MAJOR\n int const DEFAULT_MATRIX_LAYOUT = MatrixLayout::ROW_MAJOR;\n#else // nothing provided or THEA_COLUMN_MAJOR defined\n int const DEFAULT_MATRIX_LAYOUT = MatrixLayout::COLUMN_MAJOR;\n#endif\n\n// Typedef common instantiations. These are fully instantiated and have no further template parameters.\n// Alignment is DISABLED for fixed-size vectorizable types (Vector4f, Matrix4f, Vector2d etc). These require special handling\n// for every class which directly or indirectly has such a member, and could lead to unexpected bugs and considerably less ease\n// of use.\n//\n// See:\n// - http://eigen.tuxfamily.org/dox/group__TopicStructHavingEigenMembers.html\n// - https://eigen.tuxfamily.org/dox/group__TopicStlContainers.html\n// - http://eigen.tuxfamily.org/dox/group__TopicFixedSizeVectorizable.html\n// - https://stackoverflow.com/q/41087043\n//\n#define THEA_DECL_MATRIX_TYPEDEFS(scalar, suffix) \\\n typedef Eigen::Matrix< scalar, 2, 2, DEFAULT_MATRIX_LAYOUT | Eigen::DontAlign > Matrix2 ## suffix; \\\n typedef Eigen::Matrix< scalar, 3, 3, DEFAULT_MATRIX_LAYOUT | Eigen::DontAlign > Matrix3 ## suffix; \\\n typedef Eigen::Matrix< scalar, 4, 4, DEFAULT_MATRIX_LAYOUT | Eigen::DontAlign > Matrix4 ## suffix; \\\n typedef Eigen::Matrix< scalar, 2, 1, MatrixLayout::COLUMN_MAJOR | Eigen::DontAlign > Vector2 ## suffix; \\\n typedef Eigen::Matrix< scalar, 3, 1, MatrixLayout::COLUMN_MAJOR | Eigen::DontAlign > Vector3 ## suffix; \\\n typedef Eigen::Matrix< scalar, 4, 1, MatrixLayout::COLUMN_MAJOR | Eigen::DontAlign > Vector4 ## suffix; \\\n typedef Eigen::Matrix< scalar, 1, 2, MatrixLayout::ROW_MAJOR | Eigen::DontAlign > RowVector2 ## suffix; \\\n typedef Eigen::Matrix< scalar, 1, 3, MatrixLayout::ROW_MAJOR | Eigen::DontAlign > RowVector3 ## suffix; \\\n typedef Eigen::Matrix< scalar, 1, 4, MatrixLayout::ROW_MAJOR | Eigen::DontAlign > RowVector4 ## suffix; \\\n typedef Eigen::Matrix< scalar, 2, Eigen::Dynamic, DEFAULT_MATRIX_LAYOUT > Matrix2X ## suffix; \\\n typedef Eigen::Matrix< scalar, 3, Eigen::Dynamic, DEFAULT_MATRIX_LAYOUT > Matrix3X ## suffix; \\\n typedef Eigen::Matrix< scalar, 4, Eigen::Dynamic, DEFAULT_MATRIX_LAYOUT > Matrix4X ## suffix; \\\n typedef Eigen::Matrix< scalar, Eigen::Dynamic, 2, DEFAULT_MATRIX_LAYOUT > MatrixX2 ## suffix; \\\n typedef Eigen::Matrix< scalar, Eigen::Dynamic, 3, DEFAULT_MATRIX_LAYOUT > MatrixX3 ## suffix; \\\n typedef Eigen::Matrix< scalar, Eigen::Dynamic, 4, DEFAULT_MATRIX_LAYOUT > MatrixX4 ## suffix;\n\nTHEA_DECL_MATRIX_TYPEDEFS(Real, )\nTHEA_DECL_MATRIX_TYPEDEFS(float, f)\nTHEA_DECL_MATRIX_TYPEDEFS(double, d)\nTHEA_DECL_MATRIX_TYPEDEFS(std::complex, cf)\nTHEA_DECL_MATRIX_TYPEDEFS(std::complex, cd)\nTHEA_DECL_MATRIX_TYPEDEFS(int, i)\n\n#undef THEA_DECL_MATRIX_TYPEDEFS\n\n// Typedef additional instantiations of fully resizable matrices, NOT including the \"plain X\" versions which will be declared\n// below with (fully optional) template arguments to avoid having to repeatedly type\n// Matrix in templated code.\n#define THEA_DECL_RESIZABLE_MATRIX_TYPEDEFS(scalar, suffix) \\\n typedef Eigen::Matrix< scalar, Eigen::Dynamic, Eigen::Dynamic, DEFAULT_MATRIX_LAYOUT > MatrixX ## suffix; \\\n typedef Eigen::Matrix< scalar, Eigen::Dynamic, 1 , MatrixLayout::COLUMN_MAJOR > VectorX ## suffix; \\\n typedef Eigen::Matrix< scalar, 1, Eigen::Dynamic, MatrixLayout::ROW_MAJOR > RowVectorX ## suffix;\n\nTHEA_DECL_RESIZABLE_MATRIX_TYPEDEFS(float, f)\nTHEA_DECL_RESIZABLE_MATRIX_TYPEDEFS(double, d)\nTHEA_DECL_RESIZABLE_MATRIX_TYPEDEFS(std::complex, cf)\nTHEA_DECL_RESIZABLE_MATRIX_TYPEDEFS(std::complex, cd)\nTHEA_DECL_RESIZABLE_MATRIX_TYPEDEFS(int, i)\n\n#undef THEA_DECL_RESIZABLE_MATRIX_TYPEDEFS\n\n/**\n * General 2D dense matrix template, alias for Eigen::Matrix with a custom default layout (row or column major) and\n * alignment preference.\n *\n * This alias currently disables alignment for all fixed-size types: fixed-size vectorizable types (Vector4f, Matrix4f,\n * Vector2d etc) require special handling for every class which directly or indirectly has such a member, and could lead to\n * unexpected bugs and considerably less ease of use.\n *\n * @see\n * - http://eigen.tuxfamily.org/dox/group__TopicStructHavingEigenMembers.html\n * - https://eigen.tuxfamily.org/dox/group__TopicStlContainers.html\n * - http://eigen.tuxfamily.org/dox/group__TopicFixedSizeVectorizable.html\n * - https://stackoverflow.com/q/41087043\n */\ntemplate \nusing Matrix = Eigen::Matrix;\n\n/**\n * General 2D dense matrix template with dynamic resizing, alias for Eigen::Matrix with Eigen::Dynamic and a custom\n * default layout (row or column major).\n */\ntemplate \nusing MatrixX = Eigen::Matrix;\n\n/**\n * General 1D dense column vector template, alias for Eigen::Matrix, with a custom alignment\n * preference.\n *\n * This alias currently disables alignment for all fixed-size types: fixed-size vectorizable types (Vector4f, Vector2d\n * etc) require special handling for every class which directly or indirectly has such a member, and could lead to unexpected\n * bugs and considerably less ease of use.\n *\n * @see\n * - http://eigen.tuxfamily.org/dox/group__TopicStructHavingEigenMembers.html\n * - https://eigen.tuxfamily.org/dox/group__TopicStlContainers.html\n * - http://eigen.tuxfamily.org/dox/group__TopicFixedSizeVectorizable.html\n * - https://stackoverflow.com/q/41087043\n */\ntemplate \nusing Vector = Eigen::Matrix;\n\n/**\n * General 1D dense column vector template with dynamic resizing, alias for Eigen::Matrix\n * with a custom default layout (row or column major).\n */\ntemplate \nusing VectorX = Eigen::Matrix;\n\n/**\n * General 1D dense row vector template, alias for Eigen::Matrix, with a custom alignment\n * preference.\n *\n * This alias currently disables alignment for all fixed-size types: fixed-size vectorizable types (RowVector4f,\n * RowVector2d etc) require special handling for every class which directly or indirectly has such a member, and could lead to\n * unexpected bugs and considerably less ease of use.\n *\n * @see\n * - http://eigen.tuxfamily.org/dox/group__TopicStructHavingEigenMembers.html\n * - https://eigen.tuxfamily.org/dox/group__TopicStlContainers.html\n * - http://eigen.tuxfamily.org/dox/group__TopicFixedSizeVectorizable.html\n * - https://stackoverflow.com/q/41087043\n */\ntemplate \nusing RowVector = Eigen::Matrix;\n\n/**\n * General 1D dense row vector template with dynamic resizing, alias for Eigen::Matrix\n * with a custom default layout (row or column major).\n */\ntemplate \nusing RowVectorX = Eigen::Matrix;\n\n//=============================================================================================================================\n// Typedef Eigen::Map wrappers for interpreting raw data as common Eigen types.\n//=============================================================================================================================\n\n#define THEA_DECL_MATRIX_MAP_TYPEDEFS(suffix) \\\n typedef Eigen::Map< Matrix2 ## suffix > Matrix2 ## suffix ## Map; \\\n typedef Eigen::Map< Matrix3 ## suffix > Matrix3 ## suffix ## Map; \\\n typedef Eigen::Map< Matrix4 ## suffix > Matrix4 ## suffix ## Map; \\\n typedef Eigen::Map< Vector2 ## suffix > Vector2 ## suffix ## Map; \\\n typedef Eigen::Map< Vector3 ## suffix > Vector3 ## suffix ## Map; \\\n typedef Eigen::Map< Vector4 ## suffix > Vector4 ## suffix ## Map; \\\n typedef Eigen::Map< RowVector2 ## suffix > RowVector2 ## suffix ## Map; \\\n typedef Eigen::Map< RowVector3 ## suffix > RowVector3 ## suffix ## Map; \\\n typedef Eigen::Map< RowVector4 ## suffix > RowVector4 ## suffix ## Map; \\\n typedef Eigen::Map< Matrix2X ## suffix > Matrix2X ## suffix ## Map; \\\n typedef Eigen::Map< Matrix3X ## suffix > Matrix3X ## suffix ## Map; \\\n typedef Eigen::Map< Matrix4X ## suffix > Matrix4X ## suffix ## Map; \\\n typedef Eigen::Map< MatrixX2 ## suffix > MatrixX2 ## suffix ## Map; \\\n typedef Eigen::Map< MatrixX3 ## suffix > MatrixX3 ## suffix ## Map; \\\n typedef Eigen::Map< MatrixX4 ## suffix > MatrixX4 ## suffix ## Map; \\\n \\\n typedef Eigen::Map< Matrix2 ## suffix const > Matrix2 ## suffix ## ConstMap; \\\n typedef Eigen::Map< Matrix3 ## suffix const > Matrix3 ## suffix ## ConstMap; \\\n typedef Eigen::Map< Matrix4 ## suffix const > Matrix4 ## suffix ## ConstMap; \\\n typedef Eigen::Map< Vector2 ## suffix const > Vector2 ## suffix ## ConstMap; \\\n typedef Eigen::Map< Vector3 ## suffix const > Vector3 ## suffix ## ConstMap; \\\n typedef Eigen::Map< Vector4 ## suffix const > Vector4 ## suffix ## ConstMap; \\\n typedef Eigen::Map< RowVector2 ## suffix const > RowVector2 ## suffix ## ConstMap; \\\n typedef Eigen::Map< RowVector3 ## suffix const > RowVector3 ## suffix ## ConstMap; \\\n typedef Eigen::Map< RowVector4 ## suffix const > RowVector4 ## suffix ## ConstMap; \\\n typedef Eigen::Map< Matrix2X ## suffix const > Matrix2X ## suffix ## ConstMap; \\\n typedef Eigen::Map< Matrix3X ## suffix const > Matrix3X ## suffix ## ConstMap; \\\n typedef Eigen::Map< Matrix4X ## suffix const > Matrix4X ## suffix ## ConstMap; \\\n typedef Eigen::Map< MatrixX2 ## suffix const > MatrixX2 ## suffix ## ConstMap; \\\n typedef Eigen::Map< MatrixX3 ## suffix const > MatrixX3 ## suffix ## ConstMap; \\\n typedef Eigen::Map< MatrixX4 ## suffix const > MatrixX4 ## suffix ## ConstMap;\n\nTHEA_DECL_MATRIX_MAP_TYPEDEFS()\nTHEA_DECL_MATRIX_MAP_TYPEDEFS(f)\nTHEA_DECL_MATRIX_MAP_TYPEDEFS(d)\nTHEA_DECL_MATRIX_MAP_TYPEDEFS(cf)\nTHEA_DECL_MATRIX_MAP_TYPEDEFS(cd)\nTHEA_DECL_MATRIX_MAP_TYPEDEFS(i)\n\n#undef THEA_DECL_MATRIX_MAP_TYPEDEFS\n\n#define THEA_DECL_RESIZABLE_MATRIX_MAP_TYPEDEFS(suffix) \\\n typedef Eigen::Map< MatrixX ## suffix > MatrixX ## suffix ## Map; \\\n typedef Eigen::Map< VectorX ## suffix > VectorX ## suffix ## Map; \\\n typedef Eigen::Map< RowVectorX ## suffix > RowVectorX ## suffix ## Map; \\\n \\\n typedef Eigen::Map< MatrixX ## suffix const > MatrixX ## suffix ## ConstMap; \\\n typedef Eigen::Map< VectorX ## suffix const > VectorX ## suffix ## ConstMap; \\\n typedef Eigen::Map< RowVectorX ## suffix const > RowVectorX ## suffix ## ConstMap;\n\nTHEA_DECL_RESIZABLE_MATRIX_MAP_TYPEDEFS(f)\nTHEA_DECL_RESIZABLE_MATRIX_MAP_TYPEDEFS(d)\nTHEA_DECL_RESIZABLE_MATRIX_MAP_TYPEDEFS(cf)\nTHEA_DECL_RESIZABLE_MATRIX_MAP_TYPEDEFS(cd)\nTHEA_DECL_RESIZABLE_MATRIX_MAP_TYPEDEFS(i)\n\n#undef THEA_DECL_RESIZABLE_MATRIX_MAP_TYPEDEFS\n\n/** Alias for Eigen::Map< Matrix<...> >. */\ntemplate < int Rows, int Cols, typename T = Real,\n int Options = DEFAULT_MATRIX_LAYOUT,\n typename StrideType = Eigen::Stride<0, 0>,\n int MapOptions = Eigen::Unaligned,\n int MaxRowsAtCompileTime = Rows,\n int MaxColsAtCompileTime = Cols >\nusing MatrixMap = Eigen::Map< Matrix,\n MapOptions, StrideType >;\n\n/** Alias for Eigen::Map< Matrix<...> const >. */\ntemplate < int Rows, int Cols, typename T = Real,\n int Options = DEFAULT_MATRIX_LAYOUT,\n typename StrideType = Eigen::Stride<0, 0>,\n int MapOptions = Eigen::Unaligned,\n int MaxRowsAtCompileTime = Rows,\n int MaxColsAtCompileTime = Cols >\nusing MatrixConstMap = Eigen::Map< Matrix const,\n MapOptions, StrideType >;\n\n/** Alias for Eigen::Map< Vector<...> >. */\ntemplate < int Size, typename T = Real,\n typename StrideType = Eigen::Stride<0, 0>,\n int MapOptions = Eigen::Unaligned,\n int Options = MatrixLayout::COLUMN_MAJOR,\n int MaxRowsAtCompileTime = Size >\nusing VectorMap = Eigen::Map< Vector, MapOptions, StrideType >;\n\n/** Alias for Eigen::Map< Vector<...> const >. */\ntemplate < int Size, typename T = Real,\n typename StrideType = Eigen::Stride<0, 0>,\n int MapOptions = Eigen::Unaligned,\n int Options = MatrixLayout::COLUMN_MAJOR,\n int MaxRowsAtCompileTime = Size >\nusing VectorConstMap = Eigen::Map< Vector const, MapOptions, StrideType >;\n\n/** Alias for Eigen::Map< RowVector<...> >. */\ntemplate < int Size, typename T = Real,\n typename StrideType = Eigen::Stride<0, 0>,\n int MapOptions = Eigen::Unaligned,\n int Options = MatrixLayout::ROW_MAJOR,\n int MaxColsAtCompileTime = Size >\nusing RowVectorMap = Eigen::Map< RowVector, MapOptions, StrideType >;\n\n/** Alias for Eigen::Map< RowVector<...> const >. */\ntemplate < int Size, typename T = Real,\n typename StrideType = Eigen::Stride<0, 0>,\n int MapOptions = Eigen::Unaligned,\n int Options = MatrixLayout::ROW_MAJOR,\n int MaxColsAtCompileTime = Size >\nusing RowVectorConstMap = Eigen::Map< RowVector const, MapOptions, StrideType >;\n\n/** Alias for Eigen::Map< MatrixX<...> >. */\ntemplate < typename T = Real,\n int Options = DEFAULT_MATRIX_LAYOUT,\n typename StrideType = Eigen::Stride<0, 0>,\n int MapOptions = Eigen::Unaligned,\n int MaxRowsAtCompileTime = Eigen::Dynamic,\n int MaxColsAtCompileTime = Eigen::Dynamic >\nusing MatrixXMap = Eigen::Map< MatrixX, MapOptions, StrideType >;\n\n/** Alias for Eigen::Map< MatrixX<...> const >. */\ntemplate < typename T = Real,\n int Options = DEFAULT_MATRIX_LAYOUT,\n typename StrideType = Eigen::Stride<0, 0>,\n int MapOptions = Eigen::Unaligned,\n int MaxRowsAtCompileTime = Eigen::Dynamic,\n int MaxColsAtCompileTime = Eigen::Dynamic >\nusing MatrixXConstMap = Eigen::Map< MatrixX const,\n MapOptions, StrideType >;\n\n/** Alias for Eigen::Map< VectorX<...> >. */\ntemplate < typename T = Real,\n typename StrideType = Eigen::Stride<0, 0>,\n int MapOptions = Eigen::Unaligned,\n int Options = MatrixLayout::COLUMN_MAJOR,\n int MaxRowsAtCompileTime = Eigen::Dynamic >\nusing VectorXMap = Eigen::Map< VectorX, MapOptions, StrideType >;\n\n/** Alias for Eigen::Map< VectorX<...> const >. */\ntemplate < typename T = Real,\n typename StrideType = Eigen::Stride<0, 0>,\n int MapOptions = Eigen::Unaligned,\n int Options = MatrixLayout::COLUMN_MAJOR,\n int MaxRowsAtCompileTime = Eigen::Dynamic >\nusing VectorXConstMap = Eigen::Map< VectorX const, MapOptions, StrideType >;\n\n/** Alias for Eigen::Map< RowVectorX<...> >. */\ntemplate < typename T = Real,\n typename StrideType = Eigen::Stride<0, 0>,\n int MapOptions = Eigen::Unaligned,\n int Options = MatrixLayout::ROW_MAJOR,\n int MaxColsAtCompileTime = Eigen::Dynamic >\nusing RowVectorXMap = Eigen::Map< RowVectorX, MapOptions, StrideType >;\n\n/** Alias for Eigen::Map< RowVectorX<...> const >. */\ntemplate < typename T = Real,\n typename StrideType = Eigen::Stride<0, 0>,\n int MapOptions = Eigen::Unaligned,\n int Options = MatrixLayout::ROW_MAJOR,\n int MaxColsAtCompileTime = Eigen::Dynamic >\nusing RowVectorXConstMap = Eigen::Map< RowVectorX const, MapOptions, StrideType >;\n\n//=============================================================================================================================\n// Typedef other useful Eigen classes.\n//=============================================================================================================================\n\n/** Alias for Eigen::Quaternion<...>. */\ntemplate using Quaternion = Eigen::Quaternion;\n\n} // namespace Thea\n\n#include \"MatrixUtil.hpp\"\n\n#endif\n", "meta": {"hexsha": "783155fabd9bfa55f06cd8fe6e09ba6662e3a88e", "size": 19984, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "Code/Source/MatVec.hpp", "max_stars_repo_name": "sidch/Thea", "max_stars_repo_head_hexsha": "d5ea3e3f1bd7389255cfabf1d55a6fe88c3c7db7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 77.0, "max_stars_repo_stars_event_min_datetime": "2016-11-06T17:25:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T16:30:34.000Z", "max_issues_repo_path": "Code/Source/MatVec.hpp", "max_issues_repo_name": "sidch/Thea", "max_issues_repo_head_hexsha": "d5ea3e3f1bd7389255cfabf1d55a6fe88c3c7db7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2017-04-22T16:47:04.000Z", "max_issues_repo_issues_event_max_datetime": "2017-04-22T16:47:04.000Z", "max_forks_repo_path": "Code/Source/MatVec.hpp", "max_forks_repo_name": "sidch/Thea", "max_forks_repo_head_hexsha": "d5ea3e3f1bd7389255cfabf1d55a6fe88c3c7db7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 20.0, "max_forks_repo_forks_event_min_datetime": "2015-10-17T20:38:50.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-18T09:56:27.000Z", "avg_line_length": 54.6010928962, "max_line_length": 128, "alphanum_fraction": 0.6408126501, "num_tokens": 4903, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303087996143, "lm_q2_score": 0.6297746074044134, "lm_q1q2_score": 0.49785591486556674}} {"text": "/*\n * 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 * 1. Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n *\n * 2. 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 * 3. Neither the name of the copyright holder nor the names of its\n * contributors may be used to endorse or promote products derived\n * 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 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 * Please contact the author(s) of this library if you have any questions.\n * Authors: David Fridovich-Keil ( dfk@eecs.berkeley.edu )\n * Erik Nelson ( eanelson@eecs.berkeley.edu )\n */\n\n///////////////////////////////////////////////////////////////////////////////\n//\n// This header defines a set of functions for converting a fundamental matrix\n// and a pair of camera intrinsics into an essential matrix, and from an\n// essential matrix to and a set of camera extrinsics.\n//\n///////////////////////////////////////////////////////////////////////////////\n\n#include \"essential_matrix_solver.h\"\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"point_3d.h\"\n#include \"triangulation.h\"\n#include \"../camera/camera.h\"\n\nDEFINE_double(min_points_visible_ratio, 0.3,\n \"Fraction of keypoint matches whose triangulation must be \"\n \"visible from both cameras. This value should be lowered if you \"\n \"expect lots of noisy matches.\");\n\nnamespace bsfm {\n\n// Compute the essential matrix from a fundamental matrix and camera intrinsics.\nMatrix3d EssentialMatrixSolver::ComputeEssentialMatrix(\n const Matrix3d& F, const CameraIntrinsics& intrinsics1,\n const CameraIntrinsics& intrinsics2) {\n // Extract intrinsics matrices.\n Matrix3d K1(intrinsics1.K());\n Matrix3d K2(intrinsics2.K());\n\n // Calculate the essential matrix.\n return K2.transpose() * F * K1;\n}\n\n// Compute the relative transformation between two cameras from an essential\n// matrix and a list of keypoint matches. Note that translation can only be\n// computed up to a scale factor.\n// NOTE: this implementation is based on Hartley & Zisserman's MVG, pg. 258.\nbool EssentialMatrixSolver::ComputeExtrinsics(\n const Matrix3d& E, const FeatureMatchList& matches,\n const CameraIntrinsics& intrinsics1, const CameraIntrinsics& intrinsics2,\n Pose& relative_pose) {\n // Initialize the W matrix.\n Matrix3d W;\n W << 0.0, -1.0, 0.0,\n 1.0, 0.0, 0.0,\n 0.0, 0.0, 1.0;\n\n // Perform an SVD on the essential matrix.\n Eigen::JacobiSVD svd;\n svd.compute(E, Eigen::ComputeFullU | Eigen::ComputeFullV);\n if (!svd.computeU() || !svd.computeV()) {\n VLOG(1) << \"Failed to compute a singular value decomposition of \"\n << \"the essential matrix.\";\n return false;\n }\n\n // The essential matrix must satisfy E = U * diag(1, 1, 0) * V^T. Use U and V\n // to get a new E, run another SVD, and get the normalized U and V.\n Matrix3d sigma(Matrix3d::Identity());\n sigma(2, 2) = 0;\n Matrix3d E_augmented = svd.matrixU() * sigma * svd.matrixV().transpose();\n\n svd.compute(E_augmented, Eigen::ComputeFullU | Eigen::ComputeFullV);\n if (!svd.computeU() || !svd.computeV()) {\n VLOG(1) << \"Failed to compute a singular value decomposition of \"\n << \"the essential matrix.\";\n return false;\n }\n\n // Compute two possibilities for rotation.\n Matrix3d R1 = svd.matrixU() * W * svd.matrixV().transpose();\n Matrix3d R2 = svd.matrixU() * W.transpose() * svd.matrixV().transpose();\n\n // Ensure positive determinants.\n if (R1.determinant() < 0)\n R1 = -R1;\n if (R2.determinant() < 0)\n R2 = -R2;\n\n // Compute two possibilities for translation\n Vector3d t1, t2;\n t1 = svd.matrixU().col(2);\n t2 = -t1;\n\n // Build four possible Poses.\n std::vector poses;\n poses.push_back(Pose(R1, t1));\n poses.push_back(Pose(R1, t2));\n poses.push_back(Pose(R2, t1));\n poses.push_back(Pose(R2, t2));\n\n // Set the first camera's position to identity in rotation and translation.\n CameraExtrinsics extrinsics1;\n extrinsics1.SetWorldToCamera(Pose());\n\n Camera camera1;\n camera1.SetExtrinsics(extrinsics1);\n camera1.SetIntrinsics(intrinsics1);\n\n // Test how many points are in front of each pose and the identity pose.\n Pose best_pose;\n int best_num_points = -1;\n\n double u = 0.0, v = 0.0;\n for (int ii = 0; ii < poses.size(); ii++) {\n int num_points = 0;\n\n CameraExtrinsics extrinsics2;\n extrinsics2.SetWorldToCamera(poses[ii]);\n\n Camera camera2;\n camera2.SetExtrinsics(extrinsics2);\n camera2.SetIntrinsics(intrinsics2);\n\n for (int jj = 0; jj < matches.size(); jj++) {\n // Triangulate points and test if the 3D estimate is in front of both\n // cameras.\n Point3D point;\n double unused = 0.0;\n if (!Triangulate(matches[jj], camera1, camera2, point, unused)) {\n continue;\n }\n\n num_points++;\n }\n\n // Update best_num_points and best_pose.\n if (num_points > best_num_points) {\n best_num_points = num_points;\n best_pose = poses[ii];\n }\n }\n\n // Return with false if not enough points found in front of the cameras.\n if (best_num_points < FLAGS_min_points_visible_ratio * matches.size()) {\n VLOG(1) << \"Did not find enough points in front of both cameras.\";\n return false;\n }\n\n relative_pose = best_pose;\n\n return true;\n}\n\n} //\\namespace bsfm\n", "meta": {"hexsha": "c8fd141453f579090f8a3035b9c2da8a9b0b89d1", "size": 6630, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/cpp/geometry/essential_matrix_solver.cpp", "max_stars_repo_name": "jamesdsmith/berkeley_sfm", "max_stars_repo_head_hexsha": "de3ae6b104602c006d939b1f3da8c497b86d39ff", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 21.0, "max_stars_repo_stars_event_min_datetime": "2016-01-14T13:52:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-03T19:30:33.000Z", "max_issues_repo_path": "src/cpp/geometry/essential_matrix_solver.cpp", "max_issues_repo_name": "jamesdsmith/berkeley_sfm", "max_issues_repo_head_hexsha": "de3ae6b104602c006d939b1f3da8c497b86d39ff", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4.0, "max_issues_repo_issues_event_min_datetime": "2015-10-17T17:01:46.000Z", "max_issues_repo_issues_event_max_datetime": "2015-10-22T20:59:43.000Z", "max_forks_repo_path": "src/cpp/geometry/essential_matrix_solver.cpp", "max_forks_repo_name": "erik-nelson/berkeley_sfm", "max_forks_repo_head_hexsha": "5bf0b45fac176ff7abfca0ff690893c1afc73c51", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2016-01-22T06:23:59.000Z", "max_forks_repo_forks_event_max_datetime": "2018-01-16T03:54:33.000Z", "avg_line_length": 35.0793650794, "max_line_length": 80, "alphanum_fraction": 0.6790346908, "num_tokens": 1687, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125737597971, "lm_q2_score": 0.6619228758499942, "lm_q1q2_score": 0.4977743254984408}} {"text": "/*\n * mesher_tester.cpp\n * Mesh_3_applications\n *\n * Created by Jane Tournois on 02/12/09.\n * Copyright 2009 INRIA. All rights reserved.\n */\n\n//#include \n#include \n#include \n\n#include \n#include \n#include \n// Implicit domain\n#include \n#include \n\n#include \n#include \"../examples/Mesh_3/implicit_functions.h\"\n#include \n#include \n\n/* INPUTS */\n// Polyhedral domain\n#include \n#include \n#include \n// Implicit domain is above\n// 3D Image\n#include \n#include \n#include \n\n/* OUTPUT */\n#include \n\n/* tools */\n#include \n#include \n#include \n\n/* OPTIONS and PARAMETERS */\n#include \nnamespace po = boost::program_options;\n\nusing namespace CGAL::parameters; //to avoid verbose function and named parameters call\n\n/* FILE SYSTEM */\n#include \n#include \n#include \n#include \n#include \nnamespace fs = boost::filesystem; \n\n/* DOMAIN */\nstruct K: public CGAL::Exact_predicates_inexact_constructions_kernel {};\n// Polyhedral domain\ntypedef CGAL::Mesh_3::Robust_intersection_traits_3 Geom_traits; // exact constructions here\ntypedef CGAL::Polyhedron_3 Polyhedron;\ntypedef CGAL::Polyhedral_mesh_domain_3 Polyhedral_domain; \n// Implicit domain\ntypedef FT_to_point_function_wrapper I_Function;\ntypedef CGAL::Implicit_multi_domain_to_labeling_function_wrapper I_Function_wrapper;\ntypedef I_Function_wrapper::Function_vector I_Function_vector;\ntypedef CGAL::Labeled_mesh_domain_3 Implicit_domain;\n// 3D Image\ntypedef CGAL::Image_3 Image;\ntypedef CGAL::Labeled_image_mesh_domain_3 Image_domain;\n\n/* TRIANGULATION */\n//Polyhedral domain\ntypedef CGAL::Mesh_triangulation_3::type Tr_polyhedron;\ntypedef CGAL::Mesh_complex_3_in_triangulation_3 C3t3_polyhedron;\n//Implicit domain\ntypedef CGAL::Mesh_triangulation_3::type Tr_implicit;\ntypedef CGAL::Mesh_complex_3_in_triangulation_3 C3t3_implicit;\n//3D Image\ntypedef CGAL::Mesh_triangulation_3::type Tr_image;\ntypedef CGAL::Mesh_complex_3_in_triangulation_3 C3t3_image;\n\n/* MESHING CRITERIA */\n//Polyhedral domain\ntypedef CGAL::Mesh_criteria_3 Mesh_criteria_polyhedron;\n//typedef Mesh_criteria_polyhedron::Facet_criteria Facet_criteria_polyhedron;\n//typedef Mesh_criteria_polyhedron::Cell_criteria Cell_criteria_polyhedron;\n//Implicit domain\ntypedef CGAL::Mesh_criteria_3 Mesh_criteria_implicit;\n//typedef Mesh_criteria_implicit::Facet_criteria Facet_criteria_implicit;\n//typedef Mesh_criteria_implicit::Cell_criteria Cell_criteria_implicit;\n//3D Image\ntypedef CGAL::Mesh_criteria_3 Mesh_criteria_image;\n//typedef Mesh_criteria_image::Facet_criteria Facet_criteria_image;\n//typedef Mesh_criteria_image::Cell_criteria Cell_criteria_image;\n\n\ntemplate \nT set_arg(const std::string& param_name,\n\t\t const std::string& param_string,\n\t\t const po::variables_map& vm)\n{\n\tif(vm.count(param_name))\n\t{\n\t\tT param_value = vm[param_name].as();\n\t\t//std::cout << param_string << \": \" << param_value << \"\\n\";\n\t\treturn param_value;\n\t}\n\telse\n\t{\n\t\t//std::cout << param_string << \" ignored.\\n\";\n\t\treturn T();\n\t}\n}\n\nvoid set_implicit_function(I_Function_vector& v,\n\t\t\t\t\t\t I_Function& f,\n\t\t\t\t\t\t const std::string& function_name,\n\t\t\t\t\t\t const po::variables_map& vm)\n{\n\tif(vm.count(function_name))\n\t{\n\t\tv.push_back(f);\n\t\tstd::cout << function_name << \" \";\n\t}\n}\n\nstd::vector split_line(const std::string& str)\n{\n\tstd::vector args;\n\t\n\tstd::string::size_type lastPos = str.find_first_not_of(\" \", 0);\n\tstd::string::size_type pos = str.find_first_of(\" \", lastPos);\n\twhile(pos != std::string::npos || lastPos != std::string::npos)\n\t{\n\t\targs.push_back(str.substr(lastPos, pos-lastPos));\n\t\tlastPos = str.find_first_not_of(\" \", pos);\n\t\tpos = str.find_first_of(\" \", lastPos);\n\t}\n\treturn args;\n}\n\ntemplate\nvoid save_histogram(std::string& filename, \n\t\t\t\t\tconst C3t3& c3t3)\n{\n\tstd::vector histo(181,0);\n\n\tfor (typename C3t3::Cell_iterator cit = c3t3.cells_begin() ;\n\t\t cit != c3t3.cells_end() ;\n\t\t ++cit)\n\t{\n\t\tif( !c3t3.is_in_complex(cit))\n\t\t\tcontinue;\n\t\t\n\t\ttypedef typename K::Point_3 Point_3;\n\t\tconst Point_3& p0 = cit->vertex(0)->point();\n\t\tconst Point_3& p1 = cit->vertex(1)->point();\n\t\tconst Point_3& p2 = cit->vertex(2)->point();\n\t\tconst Point_3& p3 = cit->vertex(3)->point();\n\t\t\n\t\tdouble a = CGAL::to_double(CGAL::abs(CGAL::Mesh_3::dihedral_angle(p0,p1,p2,p3)));\n\t\thisto[std::floor(a)] += 1;\n\t\ta = CGAL::to_double(CGAL::abs(CGAL::Mesh_3::dihedral_angle(p0, p2, p1, p3)));\n\t\thisto[std::floor(a)] += 1;\n\t\ta = CGAL::to_double(CGAL::abs(CGAL::Mesh_3::dihedral_angle(p0, p3, p1, p2)));\n\t\thisto[std::floor(a)] += 1;\n\t\ta = CGAL::to_double(CGAL::abs(CGAL::Mesh_3::dihedral_angle(p1, p2, p0, p3)));\n\t\thisto[std::floor(a)] += 1;\n\t\ta = CGAL::to_double(CGAL::abs(CGAL::Mesh_3::dihedral_angle(p1, p3, p0, p2)));\n\t\thisto[std::floor(a)] += 1;\n\t\ta = CGAL::to_double(CGAL::abs(CGAL::Mesh_3::dihedral_angle(p2, p3, p0, p1)));\n\t\thisto[std::floor(a)] += 1;\n\t}\n\tstd::ofstream file(filename.c_str());\n\tstd::copy(histo.begin(), histo.end(), std::ostream_iterator(file, \"\\n\"));\t\n}\n\n\ntemplate\nMeshingCriteria get_parameters(const std::string& param_line,\n\t\t\t\t\t\t\t po::variables_map& vm)\n{\n\tpo::options_description mesh(\"Mesh generation parameters\");\n\tmesh.add_options()\n (\"mesh\", \"Generate mesh\")\n\t(\"facet_angle\", po::value(), \"Set facet angle bound\")\n\t(\"facet_size\", po::value(), \"Set facet size bound\")\n\t(\"facet_error\", po::value(), \"Set approximation error bound\")\n\t(\"tet_shape\", po::value(), \"Set tet radius-edge bound\")\n\t(\"tet_size\", po::value(), \"Set tet size bound\");\n\t\n\tpo::options_description implicit_functions(\"Implicit functions\");\n\timplicit_functions.add_options()\n\t(\"torus\", \"Mesh torus function\")\n\t(\"sphere\", \"Mesh sphere function\")\n\t(\"chair\", \"Mesh chair function\")\n\t(\"tanglecube\", \"Mesh tanglecube function\")\n\t(\"cube\", \"Mesh cube function\")\n\t(\"ellipsoid\", \"Mesh ellipsoid function\")\n\t(\"heart\", \"Mesh heart function\")\n\t(\"octic\", \"Mesh octic function\");\n\t\n\tpo::options_description optim(\"Optimization parameters\");\n\toptim.add_options()\n\t(\"exude\", \"Exude mesh after refinement\")\n\t(\"perturb\", po::value(), \"Perturb mesh after refinement (sliver removal)\")\n\t(\"lloyd\", po::value(), \"Lloyd smoothing after refinement. arg is max nb iterations\")\n\t(\"odt\", po::value(), \"ODT smoothing after refinement. arg is max nb iterations\");\n\t\n\tpo::options_description additional_options(\"Options\");\n\tadditional_options.add_options()\n\t(\"off_vertices\", po::value(), \"Use polyhedron vertices as initialization step\")\n\t(\"no_label_rebind\", \"Don't rebind cell labels in medit output\")\n\t(\"show_patches\", \"Show surface patches in medit output\");\n\t\n\tpo::options_description cmdline_options(\"Usage\", 1);\n\tcmdline_options.add(mesh).add(implicit_functions).add(optim).add(additional_options);\n\t\n\tstd::vector args = split_line(param_line);\n\tpo::store(po::command_line_parser(args).options(cmdline_options).run(), vm);\n\tpo::notify(vm);\n\n\tdouble facet_angle = set_arg(\"facet_angle\", \"Facet angle\", vm);\n\tdouble facet_size = set_arg(\"facet_size\", \"Facet size\", vm);\n\tdouble facet_error = set_arg(\"facet_error\", \"Facet approximation error\", vm);\n\tdouble tet_shape = set_arg(\"tet_shape\",\"Tet shape (radius-edge)\", vm);\n\tdouble tet_size = set_arg(\"tet_size\",\"Tet size\", vm);\n\n\ttypename MeshingCriteria::Facet_criteria fc(facet_angle, facet_size, facet_error);\n\ttypename MeshingCriteria::Cell_criteria cc(tet_shape, tet_size);\n\treturn MeshingCriteria(fc, cc);\t\n}\n\nvoid get_implicit_function(const po::variables_map& vm,\n\t\t\t\t\t\t I_Function_vector& fv)\n{\n\t// Define functions\n\tI_Function f1( &torus_function);\n\tI_Function f2( &sphere_function<3>);\n\tI_Function f3( &chair_function);\n\tI_Function f4( &tanglecube_function);\n\tI_Function f5( &cube_function);\n\tI_Function f6( &ellipsoid_function);\n\tI_Function f7( &heart_function);\n\tI_Function f8( &octic_function);\n\t\n\tstd::cout << \"Function(s): \";\n\tset_implicit_function(fv, f1, \"torus\", vm);\n\tset_implicit_function(fv, f2, \"sphere\", vm);\n\tset_implicit_function(fv, f3, \"chair\", vm);\n\tset_implicit_function(fv, f4, \"tanglecube\", vm);\n\tset_implicit_function(fv, f5, \"cube\", vm);\n\tset_implicit_function(fv, f6, \"ellipsoid\", vm);\n\tset_implicit_function(fv, f7, \"heart\", vm);\n\tset_implicit_function(fv, f8, \"octic\", vm);\n\tstd::cout << \"\\n\\n\";\n\t\n\tif(fv.empty())\n\t\tstd::cout << \"Warning: No implicit function set.\\n\";\t\n}\n\n\ntemplate \nclass Domain_builder\n{\npublic:\n /*void build(const std::string& str);\n Domain domain();*/\n};\n\ntemplate <>\nclass Domain_builder\n{\n typedef Polyhedral_domain Domain;\npublic:\n Domain_builder(const std::string& str)\n : domain_(NULL)\n {\n std::ifstream input(str.c_str());\n input >> polyhedron_;\n domain_ = new Domain(polyhedron_);\n }\n \n ~Domain_builder() { delete domain_; }\n \n Domain& domain() { return *domain_; }\n\nprivate:\n Domain* domain_;\n Polyhedron polyhedron_;\n};\n\ntemplate <>\nclass Domain_builder\n{\n typedef Image_domain Domain;\npublic:\n Domain_builder(const std::string& str)\n : domain_(NULL)\n {\n image_.read(str.c_str());\n domain_ = new Domain(image_, 1e-6);\n }\n \n ~Domain_builder() { delete domain_; }\n \n Domain& domain() { return *domain_; }\n \nprivate:\n Domain* domain_;\n Image image_;\n};\n\n//template <>\n//class Domain_builder\n//{\n// typedef Implicit_domain Domain;\n//public:\n// Domain_builder()\n// :\tf1_( &torus_function);\n//\t, f2_( &sphere_function<3>);\n//\t, f3_( &chair_function);\n//\t, f4_( &tanglecube_function);\n//\t, f5_( &cube_function);\n// , f6_( &ellipsoid_function);\n//\t, f7_( &heart_function);\n//\t, f8_( &octic_function);\n// \n// void build(const std::string& str)\n// {\n// Image image;\n// image.read(str.c_str());\n// delete domain_;\n// domain_ = new Domain(image, 1e-6);\n// }\n// \n// Domain& domain() { return *domain_; }\n// \n//private:\n// Domain* domain_;\n// \n// // Define functions\n//\tI_Function f1_;\n//\tI_Function f2_;\n//\tI_Function f3_;\n//\tI_Function f4_;\n//\tI_Function f5_;\n//\tI_Function f6_;\n//\tI_Function f7_;\n//\tI_Function f8_;\n//};\n\n\n\ntemplate \nvoid mesh(const std::string& data, const po::variables_map& vm)\n{\n if(!fs::is_directory(data))\n std::cout << \"!! Problem while reading \" << data << \"\\n\";\n\t\n std::string output_dir;\n if(vm.count(\"outdir\"))\n output_dir = vm[\"outdir\"].as();\n else output_dir = data + \"output\";\n if(!fs::is_directory(output_dir) && !fs::create_directory(output_dir))\n std::cout << \"!! Problem while creating \" << output_dir << \"\\n\";\n \n fs::path path(data);\n for(fs::directory_iterator it(path); it != fs::directory_iterator(); ++it)\n {\n if(fs::is_directory(*it)\n || (fs::extension(*it) != \".off\" && (fs::extension(*it) != \".inr\" && ( fs::extension(fs::basename(*it)) != \".inr\" || fs::extension(*it) != \".gz\"))) )\n continue;\n \n std::string line_param;\n std::string filename(fs::basename(*it));\n if ( fs::extension(*it) == \".gz\" )\n filename = fs::basename(fs::basename(*it));\n std::string filename_param(data + filename + \".txt\");\n \n std::ifstream file_param(filename_param.data()); //parameters\n if(!file_param) \n {\n std::cout << \"Could not read parameters in : '\" << filename_param << \"'. Next file.\" << std::endl;\n continue;\n }\n unsigned int i = 1;\n \n // Timer\n CGAL::Timer timer;\n timer.start();\n \n // we keep c3t3 between lines\n C3T3 c3t3_save;\n \n //Load the domain\n std::cout << \"****** [\" << filename << \"] Create domain...\";\n std::flush(std::cout);\n Domain_builder domain_builder(it->path().string());\n std::cout <<\"done (\" << timer.time() << \"s) ******\\n\\n\";\n \n while(std::getline(file_param,line_param))\n {\n std::cout << \"*** Meshing \" << filename << \"[\" << i << \"] with : \" << line_param << std::endl;\n\n po::variables_map vm_p;\n Mesh_criteria mcp = get_parameters(line_param, vm_p);\n \n //Mesh generation (reload domain and rebuild c3t3)\n if ( vm_p.count(\"mesh\") )\n {\n timer.stop();\n timer.reset();\n timer.start();\n std::cout << \" Generate mesh...\";\n std::flush(std::cout);\n c3t3_save = CGAL::make_mesh_3(domain_builder.domain(), mcp, no_exude(), no_perturb());\n std::cout << \"done (\" << timer.time() << \"s - \"\n << c3t3_save.triangulation().number_of_vertices() << \" vertices, \"\n << c3t3_save.number_of_cells() << \" cells)\\n\";\n }\n \n C3T3 c3t3 = c3t3_save;\n \n //Optimization\n timer.stop();\n timer.reset();\n timer.start();\n if(vm_p.count(\"lloyd\"))\n {\n std::cout << \" Lloyd optimization...\";\n std::flush(std::cout);\n CGAL::lloyd_optimize_mesh_3(c3t3, domain_builder.domain(), max_iteration_number=vm_p[\"lloyd\"].as());\n std::cout << \"done (\" << timer.time() << \"s)\\n\";\n }\n timer.stop();\n timer.reset();\n timer.start();\n if(vm_p.count(\"odt\"))\n {\n std::cout << \" Odt optimization...\";\n std::flush(std::cout);\n CGAL::odt_optimize_mesh_3(c3t3, domain_builder.domain(), max_iteration_number=vm_p[\"odt\"].as());\n std::cout << \"done (\" << timer.time() << \"s)\\n\";\n }\t\n timer.stop();\n timer.reset();\n timer.start();\n if(vm_p.count(\"perturb\"))\n {\n std::cout << \" Perturbation...\";\n std::flush(std::cout);\n CGAL::perturb_mesh_3(c3t3, domain_builder.domain(), time_limit=vm_p[\"perturb\"].as());\n std::cout << \"done (\" << timer.time() << \"s)\\n\";\n }\n timer.stop();\n timer.reset();\n timer.start();\n if(vm_p.count(\"exude\"))\n {\n std::cout << \" Exudation...\";\n std::flush(std::cout);\n CGAL::exude_mesh_3(c3t3);\n std::cout << \"done (\" << timer.time() << \"s)\\n\";\n }\n timer.stop();\n timer.reset();\n timer.start();\n \n //save mesh\n std::cout << \" Save mesh...\";\n std::stringstream ssout;\n ssout << i;\t\t\t\t\n std::string output_filename = output_dir +\"/\" + filename + \"-out-\" + ssout.str().c_str() + \".mesh\";\n std::ofstream medit_file(output_filename.c_str());\n c3t3.output_to_medit(medit_file, !vm_p.count(\"no_label_rebind\"), vm_p.count(\"show_patches\"));\n \n //save histogram\n std::cout << \"done. \\n Save histogram...\";\n std::string histo_filename = output_dir +\"/\" + filename + \"-histo-\" + ssout.str().c_str() + \".txt\";\n save_histogram(histo_filename, c3t3);\n i++;\n std::cout << \"done.\\n\\n\\n\";\n }\n }\n}\n\n\nint main(int argc, char** argv)\n{\n\t// options\n\tpo::options_description generic(\"Options\");\n\tgeneric.add_options()(\"help\", \"Produce help message\")\n\t(\"polyhedron\", \"Test the polyhedral domain mesher\")\n\t(\"implicit\", \"Test the implicit domain mesher\")\n\t(\"image\", \"Test the 3D image domain mesher\")\n\t(\"outdir\", po::value(), \"Output directory. arg is location\");\n\t\n\tpo::options_description cmdline_options(\"Usage\", 1);\n\tcmdline_options.add(generic);//.add(others);\n\t\n\tpo::variables_map vm;\n\tpo::store(po::parse_command_line(argc, argv, cmdline_options), vm);\n\tpo::notify(vm);\n\t\n\tif(vm.count(\"help\") || argc < 2)\n\t{\n\t\tstd::cout << cmdline_options << std::endl;\n\t\tstd::cout << \"* Polyhedra: .off files should be in applications/data/Polyhedra\\n\";\n\t\tstd::cout << \"* Images: .inr.gz files should be in applications/data/3D_images\\n\";\n\t\tstd::cout << \" Note: for each file toto.domain, add a toto.txt file with meshing parameters\\n\\n\";\n\t\treturn 1;\n\t}\n\t\n\t//what are we testing\n\tbool mesh_polyhedra = vm.count(\"polyhedron\");\n\tbool mesh_implicit = vm.count(\"implicit\");\n\tbool mesh_images = vm.count(\"image\");\n\t\n\t// iterate on data files\n\tstd::string data_dir(\"data\"); // or a user defined path...\n\tfs::path data_path(data_dir); \n\t\n\tif(mesh_polyhedra)\n\t{\n\t\tstd::string data_poly = data_dir + \"/Polyhedra/\";\n mesh(data_poly,vm); \n\t}\n\n\tif(mesh_images)\n\t{\n\t\tstd::string data_img = data_dir + \"/3D_images/\";\n mesh(data_img,vm); \n }\n\t\n\tif(mesh_implicit)\n\t{\n\t\tstd::string data_imp = data_dir + \"/Implicit/\";\n\t\t//mesh(data_imp,vm); \n\t}\n\treturn 0;\n}\n", "meta": {"hexsha": "ee09c482d570601606b5a638361cc8d5716a3c00", "size": 17314, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "graphics/cgal/Mesh_3/applications/mesher_tester.cpp", "max_stars_repo_name": "hlzz/dotfiles", "max_stars_repo_head_hexsha": "0591f71230c919c827ba569099eb3b75897e163e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2016-03-30T14:31:52.000Z", "max_stars_repo_stars_event_max_datetime": "2019-02-02T05:01:32.000Z", "max_issues_repo_path": "graphics/cgal/Mesh_3/applications/mesher_tester.cpp", "max_issues_repo_name": "hlzz/dotfiles", "max_issues_repo_head_hexsha": "0591f71230c919c827ba569099eb3b75897e163e", "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": "graphics/cgal/Mesh_3/applications/mesher_tester.cpp", "max_forks_repo_name": "hlzz/dotfiles", "max_forks_repo_head_hexsha": "0591f71230c919c827ba569099eb3b75897e163e", "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": 31.7688073394, "max_line_length": 156, "alphanum_fraction": 0.6699780524, "num_tokens": 4840, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8397339596505964, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.497682270732087}} {"text": "// -*-coding: mule-utf-8-unix; fill-column: 58; -*-\n\n/**\n * @file\n * A retarget algo abstraction\n *\n * @author Sergei Lodyagin \n */\n\n#include \n#include \n#include \n#include \n#include \"types/fixed.h\"\n#include \"types/abstract_iterator.h\"\n#include \"algos/retarget.h\"\n#include \"log.h\"\n#include \"util.h\"\n#include \"pars.h\"\n#include \"btc_time.h\"\n#include \"checkpoints.h\"\n#include \"main.h\"\n#include \"types.h\"\n\nusing namespace types;\n\nextern std::map mapBlockIndex; \nextern CBlockIndex* pindexGenesisBlock;\n\nnamespace retarget {\n\ntemplate\nclass difficulty_impl;\n\n//! Allows change difficulty only by 2 or 1/2\ntemplate<>\nclass difficulty_impl\n : public difficulty\n{\npublic:\n compact_bignum_t next_block_difficulty(\n const duration desired_timespan,\n const iterator& rbegin,\n const iterator& rend\n ) override\n {\n if (rbegin == rend)\n return min_difficulty_by_design;\n\n assert(height_diff(rbegin, rend) > 0);\n\n auto prev = rbegin;\n ++prev;\n const auto actual_timespan = \n rbegin->time - prev->time;\n return (\n (actual_timespan < desired_timespan)\n ? rbegin->difficulty >> 1\n : rbegin->difficulty << 1\n ).GetCompact();\n }\n\n compact_bignum_t dos_min_difficulty(\n compact_bignum_t last_reliable_block_difficulty,\n coin::times::block::clock::duration past\n ) const override\n {\n return min_difficulty_by_design;\n }\n};\n\ntemplate<>\nclass difficulty_impl\n : public difficulty\n{\npublic:\n //! The limit parameter for dos_min_difficulty()\n const percent_t adjustment_by_design = 110.0_pct;\n\n compact_bignum_t next_block_difficulty(\n const duration desired_timespan,\n const iterator& rbegin,\n const iterator& rend\n ) override\n {\n if (rbegin == rend)\n return min_difficulty_by_design;\n\n auto prev = rbegin;\n ++prev;\n auto nActualTimespan = rbegin->time - prev->time;\n\n LOG() << \" nActualTimespan = \" \n << nActualTimespan\n << \" before bounds\\n\";\n\n // thanks to RealSolid & WDC for this code \n \n if ( pars::digishield::limit_steps() ) //switch off for development purposes\n {\n //Amplitude Filter by daft27\n nActualTimespan = desired_timespan \n + (nActualTimespan - desired_timespan)/8;\n \n //Guts of DigiShield Retarget\n if (nActualTimespan < desired_timespan * 3/4)\n nActualTimespan = desired_timespan * 3/4;\n \n if (nActualTimespan > desired_timespan * 3/2) \n nActualTimespan = desired_timespan * 3/2;\n }\n\n if ( coin::times::block::zero_duration == nActualTimespan )\n {\n nActualTimespan = coin::times::block::seconds(1);\n }\n\n // Retarget\n const auto last_block_difficulty =\n rbegin->difficulty;\n CBigNum bnNew = last_block_difficulty;\n bnNew *= to_fixed(nActualTimespan);\n bnNew /= to_fixed(desired_timespan);\n \n if (bnNew > min_difficulty_by_design)\n bnNew = min_difficulty_by_design;\n\n LOG() \n << \"GetNextWorkRequired [DigiShield] RETARGET \\n\"\n << \"retargetTimespan = \" << desired_timespan\n << \" nActualTimespan = \" << nActualTimespan\n << \"\\nBefore: \" << last_block_difficulty << ' '\n << CBigNum(last_block_difficulty).getuint256()\n << \"\\nAfter: \" << bnNew.GetCompact() << ' '\n << bnNew.getuint256() << '\\n';\n \n return bnNew.GetCompact();\n }\n\n compact_bignum_t dos_min_difficulty(\n compact_bignum_t last_reliable_block_difficulty,\n coin::times::block::clock::duration past\n ) const override\n {\n if (past < coin::times::block::zero_duration)\n throw types::exception(\n \"block with timestamp before last checkpoint\"\n );\n \n return std::min(\n CBigNum(last_reliable_block_difficulty)\n * past / block_period_by_design\n * adjustment_by_design,\n CBigNum(min_difficulty_by_design)\n ).GetCompact();\n }\n};\n\ntemplate<>\nclass difficulty_impl : public difficulty\n{\npublic:\n const int past_blocks_min = \n pars::kgw::past_min() / block_period_by_design;\n const int past_blocks_max = \n pars::kgw::past_max() / block_period_by_design;\n\n compact_bignum_t next_block_difficulty(\n const duration desired_timespan,\n const iterator& rbegin,\n const iterator& rend\n ) override\n {\n using namespace coin::times::block;\n\n // TODO don't use floating point\n using float_duration = std::chrono::duration;\n\n // early blocks rule\n if (height_diff(rbegin, rend) < past_blocks_min)\n return min_difficulty_by_design;\n\n iterator start = rbegin;\n std::advance(start, past_blocks_min - 1);\n\n int64_t mass = past_blocks_min - 1;\n const auto breaking_el = std::find_if(\n start,\n rend,\n [\n this,\n desired_timespan,\n &rbegin,\n &mass\n ]\n (const block::info_type& bi)\n {\n // != 0: fixes the same-time blocks retargetting\n // exploit\n constexpr auto min_duration = seconds(1);\n\n if (++mass > past_blocks_max)\n return true;\n\n const clock::duration desired_passed = \n desired_timespan * mass;\n const clock::duration actual_passed = \n // the timewrap fix (part 1)\n (rbegin->time <= bi.time)\n ? min_duration\n : rbegin->time - bi.time;\n \n\n assert(actual_passed != zero_duration);\n const double PastRateAdjustmentRatio =\n (desired_passed != zero_duration)\n ?\n std::chrono::duration_cast(\n desired_passed\n )\n / std::chrono::duration_cast(\n actual_passed\n ) \n :\n 1.0;\n\n // TODO tabulate it as fixed point values\n const double EventHorizonDeviation = \n 1 + (0.7084 \n * pow((double(mass)/double(past_blocks_min)), \n -1.228));\n\n const double EventHorizonDeviationFast = \n EventHorizonDeviation;\n const double EventHorizonDeviationSlow = \n 1.0 / EventHorizonDeviation;\n \n return PastRateAdjustmentRatio <= \n EventHorizonDeviationSlow \n || PastRateAdjustmentRatio >= \n EventHorizonDeviationFast;\n }\n );\n\n const auto distance = height_diff(rbegin, breaking_el);\n assert(distance >= 0);\n\n const CBigNum PastDifficultyAverage = \n std::accumulate(\n rbegin, \n breaking_el, \n CBigNum(0),\n [](const CBigNum& acc, const block::info_type& bi)\n {\n return acc + bi.difficulty;\n }\n ) / (distance + 1);\n\n // != 0: fixes the same-time blocks retargetting\n // exploit\n constexpr auto min_duration = seconds(1);\n\n const auto range_desired_timespan = \n desired_timespan * (distance + 1);\n const auto range_actual_timespan =\n // the timewrap fix (part 2)\n (rbegin->time <= breaking_el->time)\n ? min_duration \n : rbegin->time - breaking_el->time;\n\n assert(range_actual_timespan != zero_duration);\n CBigNum bnNew(PastDifficultyAverage);\n if (range_desired_timespan != zero_duration)\n {\n // actual time passed\n bnNew *= to_fixed(range_actual_timespan); \n // desired\n bnNew /= to_fixed(range_desired_timespan);\n }\n if (bnNew > min_difficulty_by_design)\n bnNew = min_difficulty_by_design;\n \n LOG() \n << \"GetNextWorkRequired [KGW] RETARGET [\"\n << height_diff(rbegin, breaking_el)\n << \" last blocks analysed]\"\n << \"\\navg difficulty: \" \n << PastDifficultyAverage.GetCompact()\n << \"\\ndesired timespan for the range = \" \n << range_desired_timespan\n << \"\\nactual timespan for the range = \" \n << range_actual_timespan\n << \"\\nBefore: \" \n << rbegin->difficulty << ' '\n << CBigNum(rbegin->difficulty)\n . getuint256()\n << \"\\nAfter: \" << bnNew.GetCompact() << ' '\n << bnNew.getuint256() << std::endl;\n \n return bnNew.GetCompact();\n }\n\n compact_bignum_t dos_min_difficulty(\n compact_bignum_t last_reliable_block_difficulty,\n coin::times::block::clock::duration past\n ) const override\n {\n return min_difficulty_by_design;\n }\n};\n\ndifficulty& difficulty::instance()\n{\n static boost::once_flag of = BOOST_ONCE_INIT;\n static difficulty* instance = nullptr;\n boost::call_once([]()\n { \n instance = new difficulty_impl\n ();\n }, of);\n\n assert(instance);\n return *instance;\n}\n\ncompact_bignum_t difficulty\n::next_block_difficulty(const CBlockIndex* pindexLast)\n{\n using namespace types;\n\n // Genesis block\n if (!pindexLast) \n return min_difficulty_by_design;\n \n // Limit adjustment step\n const auto pindexFirst = pindexLast->pprev;\n if (!pindexFirst)\n return pindexLast->nBits; // slod\n\n return next_block_difficulty(\n block_period_by_design,\n block::const_iterator(pindexLast),\n block::const_iterator(pindexGenesisBlock)\n );\n}\n\ndifficulty::difficulty()\n : min_difficulty_by_design(\n pars::testnet_switch(pars::min_difficulty_by_design)\n ),\n block_period_by_design(\n pars::testnet_switch(pars::block_period_by_design)\n )\n{\n}\n\nconst CBlockIndex* difficulty\n::dos_last_reliable_block()\n{\n static const CBlockIndex* last_checkpointed_block =\n Checkpoints::GetLastCheckpoint(mapBlockIndex);\n\n if (last_checkpointed_block)\n return last_checkpointed_block;\n else\n {\n assert(pindexGenesisBlock);\n return pindexGenesisBlock;\n }\n}\n\n} // retarget\n", "meta": {"hexsha": "2f3cc958f91a25a5cd9647b154511688c261189a", "size": 9628, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/algos/retarget.cpp", "max_stars_repo_name": "coinkeeper/2015-04-19_21-26_umbrella-ltc", "max_stars_repo_head_hexsha": "8793c46ec070c01204b3838818e2c0dbad0c8185", "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/algos/retarget.cpp", "max_issues_repo_name": "coinkeeper/2015-04-19_21-26_umbrella-ltc", "max_issues_repo_head_hexsha": "8793c46ec070c01204b3838818e2c0dbad0c8185", "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/algos/retarget.cpp", "max_forks_repo_name": "coinkeeper/2015-04-19_21-26_umbrella-ltc", "max_forks_repo_head_hexsha": "8793c46ec070c01204b3838818e2c0dbad0c8185", "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": 25.8123324397, "max_line_length": 80, "alphanum_fraction": 0.6477980889, "num_tokens": 2437, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8397339516289534, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.4976822659779271}} {"text": "\n// BLAS level 3 -- complex numbers\n\n//#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING\n\n#include \n#include \n#include \n#include \n#include \n#ifdef F_USE_STD_VECTOR\n#include \n#include \n#endif \n#include \"utils.h\" \n\nnamespace ublas = boost::numeric::ublas;\nnamespace blas = boost::numeric::bindings::blas;\nnamespace bindings = boost::numeric::bindings;\n\nusing std::cout;\nusing std::endl; \n\ntypedef double real_t;\ntypedef std::complex cmplx_t; \n\n#ifndef F_USE_STD_VECTOR\ntypedef ublas::matrix m_t;\n#else\ntypedef ublas::matrix > m_t;\n#endif \n\nint main() {\n\n cout << endl; \n\n m_t a (2, 2);\n a (0, 0) = cmplx_t (1., 0.);\n a (0, 1) = cmplx_t (2., 0.);\n a (1, 0) = cmplx_t (3., 0.);\n a (1, 1) = cmplx_t (4., 0.);\n print_m (a, \"A\"); \n cout << endl; \n\n m_t b (2, 3);\n b (0, 0) = cmplx_t (1., 0.);\n b (0, 1) = cmplx_t (2., 0.);\n b (0, 2) = cmplx_t (3., 0.);\n b (1, 0) = cmplx_t (1., 0.);\n b (1, 1) = cmplx_t (2., 0.);\n b (1, 2) = cmplx_t (3., 0.);\n print_m (b, \"B\"); \n cout << endl; \n \n m_t c (2, 3);\n\n // c = a b\n blas::gemm ( 1.0, a, b, 0.0, c); \n print_m (c, \"A B\"); \n cout << endl; \n\n a (0, 0) = cmplx_t (0., 1.);\n a (0, 1) = cmplx_t (0., 2.);\n a (1, 0) = cmplx_t (0., 3.);\n a (1, 1) = cmplx_t (0., 4.);\n print_m (a, \"A\"); \n cout << endl; \n \n // c = a b\n blas::gemm (1.0, a, b, 0.0, c); \n print_m (c, \"A B\"); \n cout << endl; \n\n // c = a^T b\n blas::gemm ( 1.0, bindings::trans(a), b, 0.0, c); \n print_m (c, \"A^T B\"); \n cout << endl; \n\n // c = a^H b\n blas::gemm (1.0, bindings::conj(a), b, 0.0, c); \n print_m (c, \"A^H B\"); \n\n cout << endl; \n\n}\n", "meta": {"hexsha": "2d336ac2c8303a5067b24f515093b2344ddf1485", "size": 1837, "ext": "cc", "lang": "C++", "max_stars_repo_path": "externals/numeric_bindings/libs/numeric/bindings/atlas/ublas_cmatr3.cc", "max_stars_repo_name": "ljktest/siconos", "max_stars_repo_head_hexsha": "85b60e62beca46e6bf06bfbd65670089e86607c7", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 137.0, "max_stars_repo_stars_event_min_datetime": "2015-06-16T15:55:28.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T06:01:59.000Z", "max_issues_repo_path": "externals/numeric_bindings/libs/numeric/bindings/atlas/ublas_cmatr3.cc", "max_issues_repo_name": "ljktest/siconos", "max_issues_repo_head_hexsha": "85b60e62beca46e6bf06bfbd65670089e86607c7", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 381.0, "max_issues_repo_issues_event_min_datetime": "2015-09-22T15:31:08.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-14T09:05:23.000Z", "max_forks_repo_path": "externals/numeric_bindings/libs/numeric/bindings/atlas/ublas_cmatr3.cc", "max_forks_repo_name": "ljktest/siconos", "max_forks_repo_head_hexsha": "85b60e62beca46e6bf06bfbd65670089e86607c7", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 30.0, "max_forks_repo_forks_event_min_datetime": "2015-08-06T22:57:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-02T20:30:20.000Z", "avg_line_length": 21.3604651163, "max_line_length": 79, "alphanum_fraction": 0.5645073489, "num_tokens": 755, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7401743735019595, "lm_q2_score": 0.6723316926137812, "lm_q1q2_score": 0.4976426893659175}} {"text": "/*\n * lstmlayer.cpp\n *\n * Feed-forward:\n * x(t) -- inputs\n * h(t-1) -- hidden state, aka outputs on prev timestep\n * c(t) -- cell state\n *\n * Phase 1: I/O gates\n * zz_a(t) = ww_xa*x(t) + ww_ha * h(t-1) + bb_a -- input\n * zz_i(t) = ww_xi*x(t) + ww_hi * h(t-1) + bb_i -- input gate\n * zz_f(t) = ww_xf*x(t) + ww_hf * h(t-1) + bb_g -- forget gate\n * zz_o(t) = ww_xo*x(t) + ww_ho * h(t-1) + bb_o -- output gate\n *\n * a(t) = activ1 (zz_a(t))\n * i(t) = activ2 (zz_i(t))\n * f(t) = activ2 (zz_f(t))\n * o(t) = activ2 (zz_o(t))\n *\n * Phase 2: State\n * c(t) = elem_prod(i(t), a(t)) + elem_prod(f(t), c(t-1))\n *\n * Phase 3: Output\n * h(t) = elem_prod(o(t), activ1(c(t))\n *\n * Back propagation:\n *\n */\n#include \n\n#include \"core/utils.h\"\n#include \"core/random.h\"\n#include \"core/functions.h\"\n#include \"lstmlayer.h\"\n\nusing namespace std;\nusing namespace boost;\nusing namespace yann;\n\n\nnamespace yann {\n\n// prefixes for read/write\nstatic const char g_ltsm_names_suffix[LstmLayer::Gate_Max + 1] = \"aifo\";\n\n////////////////////////////////////////////////////////////////////////////////////////////////\n//\n// LstmLayer_Context implementation\n//\nclass LstmLayer_Context :\n public Layer::Context\n{\n typedef Layer::Context Base;\n\n friend class LstmLayer;\n\npublic:\n LstmLayer_Context(\n const MatrixSize & output_size,\n const MatrixSize & max_batch_size) :\n Base(output_size, max_batch_size),\n _pos(0)\n {\n init();\n }\n\n LstmLayer_Context(\n const RefVectorBatch & output) :\n Base(output),\n _pos(0)\n {\n init();\n }\n\n // Layer::Context overwrites\n virtual void reset_state()\n {\n Base::reset_state();\n\n _pos = 0;\n }\n\nprivate:\n void init()\n {\n for(auto & zz_gate: _zz_gate) {\n zz_gate.resize(get_batch_size(), get_output_size());\n }\n for(auto & gate: _gate) {\n gate.resize(get_batch_size(), get_output_size());\n }\n\n _cc.resize(get_batch_size(), get_output_size());\n _activ_cc.resize(get_batch_size(), get_output_size());\n\n _hh.resize(get_batch_size(), get_output_size());\n }\n\nprotected:\n MatrixSize _pos;\n VectorBatch _zz_gate[LstmLayer::Gate_Max]; // pre-activation function results for each gate\n VectorBatch _gate[LstmLayer::Gate_Max]; // post-activation function results for each gate\n VectorBatch _cc; // cell state (save it for each step)\n VectorBatch _activ_cc; // activ1(c(t))\n VectorBatch _hh; // hidden state aka output (save it for each step)\n}; // class LstmLayer_Context\n\n////////////////////////////////////////////////////////////////////////////////////////////////\n//\n// LstmLayer_TrainingContext implementation\n//\nclass LstmLayer_TrainingContext :\n public LstmLayer_Context\n{\n typedef LstmLayer_Context Base;\n friend class LstmLayer;\n\npublic:\n LstmLayer_TrainingContext(\n const MatrixSize & input_size,\n const MatrixSize & output_size,\n const MatrixSize & batch_size,\n const unique_ptr & updater) :\n Base(output_size, batch_size)\n {\n init(updater, input_size);\n }\n\n LstmLayer_TrainingContext(\n const MatrixSize & input_size,\n const RefVectorBatch & output,\n const unique_ptr & updater) :\n Base(output)\n {\n init(updater, input_size);\n }\n\n // Layer::Context overwrites\n virtual void start_epoch()\n {\n Base::start_epoch();\n\n for(auto & ww_x_updater: _ww_x_updater) {\n YANN_SLOW_CHECK(ww_x_updater);\n ww_x_updater->start_epoch();\n }\n for(auto & ww_h_updater: _ww_h_updater) {\n YANN_SLOW_CHECK(ww_h_updater);\n ww_h_updater->start_epoch();\n }\n for(auto & bb_updater: _bb_updater) {\n YANN_SLOW_CHECK(bb_updater);\n bb_updater->start_epoch();\n }\n }\n\n virtual void reset_state()\n {\n Base::reset_state();\n\n for(auto & delta_ww_x: _delta_ww_x) {\n delta_ww_x.setZero();\n }\n for(auto & delta_ww_h: _delta_ww_h) {\n delta_ww_h.setZero();\n }\n for(auto & delta_bb: _delta_bb) {\n delta_bb.setZero();\n }\n\n for(auto & ww_x_updater: _ww_x_updater) {\n YANN_SLOW_CHECK(ww_x_updater);\n ww_x_updater->reset();\n }\n for(auto & ww_h_updater: _ww_h_updater) {\n YANN_SLOW_CHECK(ww_h_updater);\n ww_h_updater->reset();\n }\n for(auto & bb_updater: _bb_updater) {\n YANN_SLOW_CHECK(bb_updater);\n bb_updater->reset();\n }\n\n _gradient_hh.setZero();\n _gradient_cc.setZero();\n }\n\nprivate:\n void init(\n const unique_ptr & updater,\n const MatrixSize & input_size)\n {\n YANN_CHECK_GT(updater, 0);\n YANN_CHECK_GT(input_size, 0);\n\n // deltas\n for(auto & delta_ww_x: _delta_ww_x) {\n delta_ww_x.resize(input_size, get_output_size());\n }\n for(auto & delta_ww_h: _delta_ww_h) {\n delta_ww_h.resize(get_output_size(), get_output_size());\n }\n for(auto & delta_bb: _delta_bb) {\n delta_bb.resize(get_output_size());\n }\n\n // updaters\n for(auto & ww_x_updater: _ww_x_updater) {\n ww_x_updater = updater->copy();\n YANN_SLOW_CHECK(ww_x_updater);\n ww_x_updater->init(input_size, get_output_size());\n }\n for(auto & ww_h_updater: _ww_h_updater) {\n ww_h_updater = updater->copy();\n YANN_SLOW_CHECK(ww_h_updater);\n ww_h_updater->init(get_output_size(), get_output_size());\n }\n for(auto & bb_updater: _bb_updater) {\n bb_updater = updater->copy();\n YANN_SLOW_CHECK(bb_updater);\n bb_updater->init(1, get_output_size()); // RowMajor\n }\n\n // gate radients\n _gradient_hh.resize(get_output_size());\n _gradient_cc.resize(get_output_size());\n _gradient_gate.resize(get_output_size());\n _gradient_zz_gate.resize(get_output_size());\n _tmp_derivative.resize(get_output_size());\n }\n\nprivate:\n Matrix _delta_ww_x[LstmLayer::Gate_Max];\n Matrix _delta_ww_h[LstmLayer::Gate_Max];\n Vector _delta_bb[LstmLayer::Gate_Max];\n\n unique_ptr _ww_x_updater[LstmLayer::Gate_Max];\n unique_ptr _ww_h_updater[LstmLayer::Gate_Max];\n unique_ptr _bb_updater[LstmLayer::Gate_Max];\n\n Vector _gradient_hh;\n Vector _gradient_cc;\n Vector _gradient_gate;\n Vector _gradient_zz_gate;\n Vector _tmp_derivative;\n}; // class LstmLayer_TrainingContext\n\n}; // namespace yann\n\n////////////////////////////////////////////////////////////////////////////////////////////////\n//\n// yann::LstmLayer implementation\n//\nyann::LstmLayer::LstmLayer(\n const MatrixSize & input_size,\n const MatrixSize & output_size) :\n _gate_activation_function(new SigmoidFunction()),\n _io_activation_function(new TanhFunction())\n{\n YANN_CHECK_GT(input_size, 0);\n\n for(auto & ww_x: _ww_x) {\n ww_x.resize(input_size, output_size);\n }\n for(auto & ww_h: _ww_h) {\n ww_h.resize(output_size, output_size);\n }\n for(auto & bb: _bb) {\n bb.resize(output_size);\n }\n}\n\nyann::LstmLayer::~LstmLayer()\n{\n}\n\nvoid yann::LstmLayer::set_values(\n const Matrix (& ww_x)[Gate_Max],\n const Matrix (& ww_h)[Gate_Max],\n const Vector (& bb)[Gate_Max])\n{\n for(auto ii = 0; ii < Gate_Max; ++ii) {\n YANN_CHECK(is_same_size(ww_x[ii], _ww_x[ii]));\n YANN_CHECK(is_same_size(ww_h[ii], _ww_h[ii]));\n YANN_CHECK(is_same_size(bb[ii], _bb[ii]));\n\n _ww_x[ii] = ww_x[ii];\n _ww_h[ii] = ww_h[ii];\n _bb[ii] = bb[ii];\n }\n}\n\nvoid yann::LstmLayer::set_activation_functions(\n const std::unique_ptr & gate_activation_function,\n const std::unique_ptr & io_activation_function)\n{\n YANN_CHECK(gate_activation_function);\n YANN_CHECK(io_activation_function);\n _gate_activation_function = gate_activation_function->copy();\n _io_activation_function = io_activation_function->copy();\n}\n\n// Layer overwrites\nbool yann::LstmLayer::is_valid() const\n{\n if(!Base::is_valid()) {\n return false;\n }\n if(!_io_activation_function || !_gate_activation_function) {\n return false;\n }\n for(auto ii = 0; ii < Gate_Max; ++ii) {\n if(!is_same_size(_ww_x[0], _ww_x[ii])) {\n return false;\n }\n if(!is_same_size(_ww_h[0], _ww_h[ii])) {\n return false;\n }\n if(!is_same_size(_bb[0], _bb[ii])) {\n return false;\n }\n }\n\n return true;\n}\n\nstd::string yann::LstmLayer::get_name() const\n{\n return \"LstmLayer\";\n}\n\nstring yann::LstmLayer::get_info() const\n{\n YANN_CHECK(is_valid());\n\n ostringstream oss;\n oss << Base::get_info()\n << \", state activation: \" << _io_activation_function->get_info()\n << \", output activation: \" << _gate_activation_function->get_info()\n ;\n return oss.str();\n}\n\nbool yann::LstmLayer::is_equal(const Layer & other, double tolerance) const\n{\n if(!Base::is_equal(other, tolerance)) {\n return false;\n }\n auto the_other = dynamic_cast(&other);\n if(the_other == nullptr) {\n return false;\n }\n // TOOD: add deep compare\n if(_io_activation_function->get_info() != the_other->_io_activation_function->get_info()) {\n return false;\n }\n if(_gate_activation_function->get_info() != the_other->_gate_activation_function->get_info()) {\n return false;\n }\n for(auto ii = 0; ii < Gate_Max; ++ii) {\n if(!_ww_x[ii].isApprox(the_other->_ww_x[ii], tolerance)) {\n return false;\n }\n if(!_ww_h[ii].isApprox(the_other->_ww_h[ii], tolerance)) {\n return false;\n }\n if(!_bb[ii].isApprox(the_other->_bb[ii], tolerance)) {\n return false;\n }\n }\n return true;\n}\n\nMatrixSize yann::LstmLayer::get_input_size() const\n{\n YANN_SLOW_CHECK(is_valid());\n return _ww_x[Gate_A].rows();\n}\n\nMatrixSize yann::LstmLayer::get_output_size() const\n{\n YANN_SLOW_CHECK(is_valid());\n return _ww_x[Gate_A].cols();\n}\n\nunique_ptr yann::LstmLayer::create_context(const MatrixSize & batch_size) const\n{\n YANN_CHECK(is_valid());\n return make_unique(get_output_size(), batch_size);\n}\nunique_ptr yann::LstmLayer::create_context(const RefVectorBatch & output) const\n{\n YANN_CHECK(is_valid());\n return make_unique(output);\n}\nunique_ptr yann::LstmLayer::create_training_context(\n const MatrixSize & batch_size, const std::unique_ptr & updater) const\n{\n YANN_CHECK(is_valid());\n YANN_CHECK(updater);\n return make_unique(\n get_input_size(), get_output_size(), batch_size, updater);\n}\nunique_ptr yann::LstmLayer::create_training_context(\n const RefVectorBatch & output, const std::unique_ptr & updater) const\n{\n YANN_CHECK(is_valid());\n YANN_CHECK(updater);\n return make_unique(\n get_input_size(), output, updater);\n}\n\ntemplate\nvoid yann::LstmLayer::feedforward_internal(\n const InputType & input,\n Context * context,\n enum OperationMode mode) const\n{\n auto ctx = dynamic_cast(context);\n YANN_CHECK(ctx);\n YANN_CHECK(is_valid());\n YANN_CHECK_LE(get_batch_size(input) + ctx->_pos, ctx->get_batch_size());\n YANN_CHECK_LE(get_batch_size(input), get_batch_size(ctx->get_output()));\n YANN_CHECK_EQ(get_batch_item_size(input), get_input_size());\n\n for(MatrixSize ii = 0; ii < get_batch_size(input); ++ii, ++ctx->_pos) {\n // Phase 1: I/O gates\n // zz_a(t) = ww_xa*x(t) + ww_ha * h(t-1) + bb_a -- input\n // zz_i(t) = ww_xi*x(t) + ww_hi * h(t-1) + bb_i -- input gate\n // zz_f(t) = ww_xf*x(t) + ww_hf * h(t-1) + bb_g -- forget gate\n // zz_o(t) = ww_xo*x(t) + ww_ho * h(t-1) + bb_o -- output gate\n auto in = get_batch(input, ii);\n auto out = get_batch(ctx->get_output(), ctx->_pos);\n auto hh = get_batch(ctx->_hh, ctx->_pos);\n if(ctx->_pos > 0) {\n const auto & hh_prev = get_batch(ctx->_hh, ctx->_pos - 1);\n for(auto jj = 0; jj < Gate_Max; ++jj) {\n auto zz_gate = get_batch(ctx->_zz_gate[jj], ctx->_pos);\n zz_gate.noalias() = MatrixFunctions::product(in, _ww_x[jj]);\n zz_gate.noalias() += MatrixFunctions::product(hh_prev, _ww_h[jj]) + _bb[jj];\n }\n } else {\n for(auto jj = 0; jj < Gate_Max; ++jj) {\n auto zz_gate = get_batch(ctx->_zz_gate[jj], ctx->_pos);\n zz_gate.noalias() = MatrixFunctions::product(in, _ww_x[jj]);\n zz_gate.noalias() += _bb[jj];\n }\n }\n\n // a(t) = activ1 (zz_a(t))\n // i(t) = activ2 (zz_i(t))\n // f(t) = activ2 (zz_f(t))\n // o(t) = activ2 (zz_o(t))\n for(auto jj = 0; jj < Gate_Max; ++jj) {\n const auto zz_gate = get_batch(ctx->_zz_gate[jj], ctx->_pos);\n auto gate = get_batch(ctx->_gate[jj], ctx->_pos);\n if(jj > 0) {\n _gate_activation_function->f(zz_gate, gate, Operation_Assign);\n } else {\n _io_activation_function->f(zz_gate, gate, Operation_Assign);\n }\n }\n\n // Phase 2: State\n // c(t) = elem_prod(i(t), a(t)) + elem_prod(f(t), c(t-1))\n const auto gate_aa = get_batch(ctx->_gate[Gate_A], ctx->_pos);\n const auto gate_ii = get_batch(ctx->_gate[Gate_I], ctx->_pos);\n const auto gate_ff = get_batch(ctx->_gate[Gate_F], ctx->_pos);\n auto cc = get_batch(ctx->_cc, ctx->_pos);\n if(ctx->_pos > 0) {\n const auto & cc_prev = get_batch(ctx->_cc, ctx->_pos - 1);\n cc.array() = gate_ii.array() * gate_aa.array() + gate_ff.array() * cc_prev.array();\n } else {\n cc.array() = gate_ii.array() * gate_aa.array();\n }\n\n // Phase 3: Output\n // h(t) = elem_prod(o(t), activ1(c(t))\n const auto gate_oo = get_batch(ctx->_gate[Gate_O], ctx->_pos);\n auto activ_cc = get_batch(ctx->_activ_cc, ctx->_pos);\n _io_activation_function->f(cc, activ_cc, Operation_Assign);\n hh.array() = gate_oo.array() * activ_cc.array();\n\n // done!\n switch(mode) {\n case Operation_Assign:\n out.noalias() = hh;\n break;\n case Operation_PlusEqual:\n out.noalias() += hh;\n break;\n }\n }\n}\n\nvoid yann::LstmLayer::feedforward(\n const RefConstVectorBatch & input,\n Context * context,\n enum OperationMode mode) const\n{\n feedforward_internal(input, context, mode);\n}\n\nvoid yann::LstmLayer::feedforward(\n const RefConstSparseVectorBatch & input,\n Context * context,\n enum OperationMode mode) const\n{\n feedforward_internal(input, context, mode);\n}\n\ntemplate<\n typename MainInputType,\n typename InputType,\n typename GradientInputType,\n typename ContextType\n>\nvoid yann::LstmLayer::backprop_gate(\n enum IOGates gate,\n const std::unique_ptr & activation_function,\n const RefConstVector & gradient_gate,\n const InputType & input,\n boost::optional gradient_in,\n ContextType * ctx) const\n{\n YANN_SLOW_CHECK(activation_function);\n YANN_SLOW_CHECK(ctx);\n\n const auto zz_gate = get_batch(ctx->_zz_gate[gate], ctx->_pos);\n const auto & ww_x = _ww_x[gate];\n const auto & ww_h = _ww_h[gate];\n auto & gradient_zz_gate = ctx->_gradient_zz_gate;\n auto & tmp_derivative = ctx->_tmp_derivative;\n\n // gate(t) = activ(zz_gate(t))\n //\n // grad(zz_gate) = grad(gate) * activ'(zz_gate)\n activation_function->derivative(zz_gate, tmp_derivative);\n gradient_zz_gate.array() = gradient_gate.array() * tmp_derivative.array();\n\n // zz_gate(t) = ww_x_gate*x(t) + ww_h_gate * h(t-1) + bb_gate\n //\n // grad(ww_x_gate) = grad(zz_gate) * d zz_gate/dww_x_gate = grad(zz_gate) * x(t)\n // grad(ww_h_gate) = grad(zz_gate) * d zz_gate/dww_h_gate = grad(zz_gate) * h(t-1)\n // grad(b) = grad(zz_gate) * d zz_gate/db = grad(zz_gate)\n YANN_SLOW_CHECK(is_same_size(ctx->_delta_ww_x[gate], _ww_x[gate]));\n YANN_SLOW_CHECK(is_same_size(ctx->_delta_ww_h[gate], _ww_h[gate]));\n YANN_SLOW_CHECK(is_same_size(ctx->_delta_bb[gate], _bb[gate]));\n ctx->_delta_ww_x[gate] += MatrixFunctions::product(input.transpose(), gradient_zz_gate);\n if(ctx->_pos > 0) {\n auto prev_hh = get_batch(ctx->_hh, ctx->_pos - 1);\n ctx->_delta_ww_h[gate] += MatrixFunctions::product(prev_hh.transpose(), gradient_zz_gate);\n }\n ctx->_delta_bb[gate].noalias() += gradient_zz_gate;\n\n // zz_gate(t) = ww_x_gate*x(t) + ww_h_gate * h(t-1) + bb_gate\n //\n // grad(h) = grad(zz_gate) * d zz_gate/dh = grad(zz_gate) * transp(ww_h_gate)\n if(ctx->_pos > 0) {\n auto & gradient_hh = ctx->_gradient_hh;\n gradient_hh.noalias() += MatrixFunctions::product(gradient_zz_gate, ww_h.transpose());\n }\n\n // zz_gate(t) = ww_x_gate*x(t) + ww_h_gate * h(t-1) + bb_gate\n //\n // grad(x) = grad(zz_gate) * d zz_gate/dx = grad(zz_gate) * transp(ww_x_gate)\n if(gradient_in) {\n (*gradient_in).noalias() += MatrixFunctions::product(gradient_zz_gate, ww_x.transpose());\n }\n}\n\ntemplate\nvoid yann::LstmLayer::backprop_internal(\n const RefConstVectorBatch & gradient_output,\n const InputType & input,\n optional gradient_input,\n Context * context) const\n{\n auto ctx = dynamic_cast(context);\n YANN_CHECK(ctx);\n YANN_CHECK(is_valid());\n YANN_CHECK_GT(get_batch_size(gradient_output), 0);\n YANN_CHECK_LE(get_batch_size(gradient_output), ctx->_pos);\n YANN_CHECK_EQ(get_batch_item_size(gradient_output), get_output_size());\n YANN_CHECK_EQ(get_batch_size(input), get_batch_size(gradient_output));\n YANN_CHECK_EQ(get_batch_item_size(input), get_input_size());\n YANN_CHECK_EQ(get_batch_item_size(input), get_input_size());\n YANN_CHECK(!gradient_input || is_same_size(input, *gradient_input));\n\n // Zero out since we will be adding to it\n if(gradient_input) {\n gradient_input->setZero();\n }\n\n for(MatrixSize ii = get_batch_size(gradient_output) - 1; ii >= 0 && (--ctx->_pos) >= 0; --ii) {\n const auto in = get_batch(input, ii);\n auto gradient_in = gradient_input ? make_optional(get_batch(*gradient_input, ii)) : boost::none;\n const auto gate_aa = get_batch(ctx->_gate[Gate_A], ctx->_pos);\n const auto gate_ii = get_batch(ctx->_gate[Gate_I], ctx->_pos);\n const auto gate_ff = get_batch(ctx->_gate[Gate_F], ctx->_pos);\n const auto gate_oo = get_batch(ctx->_gate[Gate_O], ctx->_pos);\n auto & gradient_gate = ctx->_gradient_gate;\n\n // note that output gradient also has the internal feedback loop\n auto & gradient_hh = ctx->_gradient_hh;\n gradient_hh += get_batch(gradient_output, ii);\n\n // State cell\n //\n // h(t) = elem_prod(o(t), activ1(c(t))\n // grad(c) = grad(h) * d h/dactiv1(c) * activ1'(c) = elem_prod(grad(h), o, activ1(c)\n const auto cc = get_batch(ctx->_cc, ctx->_pos);\n auto & gradient_cc = ctx->_gradient_cc;\n auto & tmp_derivative = ctx->_tmp_derivative;\n _io_activation_function->derivative(cc, tmp_derivative);\n // add to the gradient from previous step\n gradient_cc.array() += gradient_hh.array() * gate_oo.array() * tmp_derivative.array();\n\n\n // Gate O: Output gate:\n //\n // h(t) = elem_prod(o(t), activ1(c(t))\n // grad(o) = grad(h) * dh/do = elem_prod(grad(h), activ1(c))\n const auto activ_cc = get_batch(ctx->_activ_cc, ctx->_pos);\n gradient_gate.array() = gradient_hh.array() * activ_cc.array();\n gradient_hh.setZero(); // we will update it in backprop_gate for next step\n backprop_gate(Gate_O, _gate_activation_function, gradient_gate, in, gradient_in, ctx);\n\n // Gate A\n //\n // c(t) = elem_prod(i(t), a(t)) + elem_prod(f(t), c(t-1))\n // grad(a) = grad(c) * dc/da = elem_prod(grad(c), i(t))\n gradient_gate.array() = gradient_cc.array() * gate_ii.array();\n backprop_gate(Gate_A, _io_activation_function, gradient_gate, in, gradient_in, ctx);\n\n // Gate I: Input gate\n //\n // c(t) = elem_prod(i(t), a(t)) + elem_prod(f(t), c(t-1))\n // grad(i) = grad(c) * dc/di = elem_prod(grad(c), a(t))\n gradient_gate.array() = gradient_cc.array() * gate_aa.array();\n backprop_gate(Gate_I, _gate_activation_function, gradient_gate, in, gradient_in, ctx);\n\n // Gate F: Forget gate\n //\n // c(t) = elem_prod(i(t), a(t)) + elem_prod(f(t), c(t-1))\n // grad(f) = grad(c) * dc/df = elem_prod(grad(c), c(t-1))\n if(ctx->_pos > 0) {\n const auto prev_cc = get_batch(ctx->_activ_cc, ctx->_pos - 1);\n gradient_gate.array() = gradient_cc.array() * prev_cc.array();\n } else {\n gradient_gate.setZero();\n }\n backprop_gate(Gate_F, _gate_activation_function, gradient_gate, in, gradient_in, ctx);\n\n // State gradient for prev step\n //\n // c(t) = elem_prod(i(t), a(t)) + elem_prod(f(t), c(t-1))\n // grad(c(t-1)) = grad(c) * dc(t)/dc(t-1) = elem_prod(grad(c(t)), f(t))\n if(ctx->_pos > 0) {\n gradient_cc.array() = gradient_cc.array() * gate_ff.array();\n }\n }\n}\n\nvoid yann::LstmLayer::backprop(\n const RefConstVectorBatch & gradient_output,\n const RefConstVectorBatch & input,\n optional gradient_input,\n Context * context) const\n{\n backprop_internal(gradient_output, input, gradient_input, context);\n}\n\nvoid yann::LstmLayer::backprop(\n const RefConstVectorBatch & gradient_output,\n const RefConstSparseVectorBatch & input,\n optional gradient_input,\n Context * context) const\n{\n // is required for MatrixFunctions<>::product\n backprop_internal(gradient_output, input, gradient_input, context);\n}\n\nvoid yann::LstmLayer::init(enum InitMode mode, boost::optional init_context)\n{\n switch (mode) {\n case InitMode_Zeros:\n for(auto & ww_x: _ww_x) {\n ww_x.setZero();\n }\n for(auto & ww_h: _ww_h) {\n ww_h.setZero();\n }\n for(auto & bb: _bb) {\n bb.setZero();\n }\n break;\n case InitMode_Random:\n {\n unique_ptr gen01 = RandomGenerator::normal_distribution(0, 1,\n init_context ? optional(init_context->seed()) : boost::none);\n for(auto & ww_x: _ww_x) {\n gen01->generate(ww_x);\n }\n for(auto & ww_h: _ww_h) {\n gen01->generate(ww_h);\n }\n for(auto & bb: _bb) {\n gen01->generate(bb);\n }\n }\n break;\n }\n}\n\nvoid yann::LstmLayer::update(Context * context, const size_t & tests_num)\n{\n auto ctx = dynamic_cast(context);\n YANN_CHECK(ctx);\n\n for(auto ii = 0; ii < Gate_Max; ++ii) {\n YANN_SLOW_CHECK(ctx->_ww_x_updater[ii]);\n YANN_SLOW_CHECK(ctx->_ww_h_updater[ii]);\n YANN_SLOW_CHECK(ctx->_bb_updater[ii]);\n\n ctx->_ww_x_updater[ii]->update(ctx->_delta_ww_x[ii], tests_num, _ww_x[ii]);\n ctx->_ww_h_updater[ii]->update(ctx->_delta_ww_h[ii], tests_num, _ww_h[ii]);\n ctx->_bb_updater[ii]->update(ctx->_delta_bb[ii], tests_num, _bb[ii]);\n }\n}\n\n// the format is (no new lines):\n// (wxa:<_ww_x[Gate_A]>,wxh:<_ww_h[Gate_A]>,ba:<_bb[Gate_A]>,\n// wxi:<_ww_x[Gate_I]>,wxi:<_ww_h[Gate_I]>,bi:<_bb[Gate_I]>,\n// wxf:<_ww_x[Gate_F]>,wxf:<_ww_h[Gate_F]>,bf:<_bb[Gate_F]>,\n// wxo:<_ww_x[Gate_O]>,wxo:<_ww_h[Gate_O]>,bo:<_bb[Gate_O]>)\nvoid yann::LstmLayer::read(std::istream & is)\n{\n Base::read(is);\n\n read_char(is, '(');\n\n for(auto ii = 0; ii < Gate_Max; ++ii) {\n const char & suffix = g_ltsm_names_suffix[ii];\n if(ii > 0) {\n read_char(is, ',');\n }\n read_object(is, string(\"wx\") + suffix, _ww_x[ii]);\n read_char(is, ',');\n read_object(is, string(\"wh\") + suffix, _ww_h[ii]);\n read_char(is, ',');\n read_object(is, string(\"b\") + suffix, _bb[ii]);\n }\n read_char(is, ')');\n}\n\n// the format is (no new lines):\n// (wxa:<_ww_x[Gate_A]>,wxh:<_ww_h[Gate_A]>,ba:<_bb[Gate_A]>,\n// wxi:<_ww_x[Gate_I]>,wxi:<_ww_h[Gate_I]>,bi:<_bb[Gate_I]>,\n// wxf:<_ww_x[Gate_F]>,wxf:<_ww_h[Gate_F]>,bf:<_bb[Gate_F]>,\n// wxo:<_ww_x[Gate_O]>,wxo:<_ww_h[Gate_O]>,bo:<_bb[Gate_O]>)\nvoid yann::LstmLayer::write(std::ostream & os) const\n{\n Base::write(os);\n\n os << \"(\";\n for(auto ii = 0; ii < Gate_Max; ++ii) {\n const char & suffix = g_ltsm_names_suffix[ii];\n if(ii > 0) {\n os << \",\";\n }\n write_object(os, string(\"wx\") + suffix, _ww_x[ii]);\n os << \",\";\n write_object(os, string(\"wh\") + suffix, _ww_h[ii]);\n os << \",\";\n write_object(os, string(\"b\") + suffix, _bb[ii]);\n }\n os << \")\";\n}\n", "meta": {"hexsha": "8f02e66c1432ee837cdb2e7c0398fc0eaf0f000e", "size": 24090, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/layers/lstmlayer.cpp", "max_stars_repo_name": "lsh123/yann", "max_stars_repo_head_hexsha": "4a12b7c1ee2d89d34772d647586b3018df6997db", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2019-08-22T18:14:44.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-01T10:25:07.000Z", "max_issues_repo_path": "src/layers/lstmlayer.cpp", "max_issues_repo_name": "lsh123/yann", "max_issues_repo_head_hexsha": "4a12b7c1ee2d89d34772d647586b3018df6997db", "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/layers/lstmlayer.cpp", "max_forks_repo_name": "lsh123/yann", "max_forks_repo_head_hexsha": "4a12b7c1ee2d89d34772d647586b3018df6997db", "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.8846153846, "max_line_length": 110, "alphanum_fraction": 0.6468659195, "num_tokens": 7015, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382236515259, "lm_q2_score": 0.5774953651858118, "lm_q1q2_score": 0.49753433108917355}} {"text": "#ifndef TRIUMF_BNMR_SLR_STR_EXP_HPP\n#define TRIUMF_BNMR_SLR_STR_EXP_HPP\n\n#include \n#include \n#include \n\n// TRIUMF: Canada's particle accelerator centre\nnamespace triumf {\n\n// β-detected nuclear magnetic resonance (β-NMR)\nnamespace bnmr {\n\n// spin-lattice relaxation (SLR)\nnamespace slr {\n\n/// pulsed stretched exponential integral (from 0 to time_p)\ntemplate \nT pulsed_str_exp_integral(T time, T time_p, T nuclear_lifetime, T slr_rate,\n T beta) {\n // integrand for the numeric integral\n auto integrand = [=](T t_p) {\n return std::exp(-(time - t_p) / nuclear_lifetime) *\n std::exp(-std::pow(slr_rate * (time - t_p), beta));\n };\n // create the integrator for tanh-sinh quadrature\n static boost::math::quadrature::tanh_sinh integrator;\n // evaluate the integral from 0 to time_p\n T Q = integrator.integrate(integrand, 0.0, time_p);\n return Q;\n}\n\n/// pulsed stretched exponential\ntemplate \nT pulsed_str_exp(T time, T nuclear_lifetime, T pulse_length, T asymmetry,\n T slr_rate, T beta) {\n if (time == 0.0) {\n return asymmetry;\n } else if (time > 0.0 and time <= pulse_length) {\n return asymmetry *\n pulsed_str_exp_integral(time, time, nuclear_lifetime, slr_rate,\n beta) /\n normalization(time, nuclear_lifetime);\n } else if (time > pulse_length) {\n return (asymmetry *\n pulsed_str_exp_integral(time, pulse_length, nuclear_lifetime,\n slr_rate, beta) /\n normalization(pulse_length, nuclear_lifetime)) /\n std::exp(-(time - pulse_length) / nuclear_lifetime);\n } else {\n return 0.0;\n }\n}\n\n/// pulsed stretched exponential (ROOT)\ntemplate T pulsed_str_exp(const T *x, const T *par) {\n return pulsed_str_exp(*x, par[0], par[1], par[2], par[3], par[4]);\n}\n\n} // namespace slr\n\n} // namespace bnmr\n\n} // namespace triumf\n\n#endif // TRIUMF_BNMR_SLR_STR_EXP_HPP", "meta": {"hexsha": "5741dd59170455335b3202c061faa0a227879055", "size": 2105, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/triumf/bnmr/slr/str_exp.hpp", "max_stars_repo_name": "rmlmcfadden/triumfpp", "max_stars_repo_head_hexsha": "da3911cdf1b0ee4600d27999d484f9a1bdb89b91", "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/triumf/bnmr/slr/str_exp.hpp", "max_issues_repo_name": "rmlmcfadden/triumfpp", "max_issues_repo_head_hexsha": "da3911cdf1b0ee4600d27999d484f9a1bdb89b91", "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/triumf/bnmr/slr/str_exp.hpp", "max_forks_repo_name": "rmlmcfadden/triumfpp", "max_forks_repo_head_hexsha": "da3911cdf1b0ee4600d27999d484f9a1bdb89b91", "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": 31.8939393939, "max_line_length": 77, "alphanum_fraction": 0.6541567696, "num_tokens": 567, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382165412809, "lm_q2_score": 0.5774953651858117, "lm_q1q2_score": 0.49753432698303995}} {"text": "#include \"matrix_utils.h\"\n#include \n#include \n\nnamespace rsurfaces\n{\n namespace MatrixUtils\n {\n void TripleTriplets(const std::vector &orig, std::vector &output)\n {\n for (const Triplet &t : orig)\n {\n output.push_back(Triplet(3 * t.row(), 3 * t.col(), t.value()));\n output.push_back(Triplet(3 * t.row() + 1, 3 * t.col() + 1, t.value()));\n output.push_back(Triplet(3 * t.row() + 2, 3 * t.col() + 2, t.value()));\n }\n }\n\n void TripleMatrix(const Eigen::MatrixXd &M, Eigen::MatrixXd &out)\n {\n for (int i = 0; i < M.rows(); i++)\n {\n for (int j = 0; j < M.cols(); j++)\n {\n out(3 * i, 3 * j) = M(i, j);\n out(3 * i + 1, 3 * j + 1) = M(i, j);\n out(3 * i + 2, 3 * j + 2) = M(i, j);\n }\n }\n }\n\n void MatrixIntoColumn(const Eigen::MatrixXd &M, Eigen::VectorXd &out)\n {\n int rows = M.rows();\n int cols = M.cols();\n\n for (int i = 0; i < rows; i++)\n {\n for (int j = 0; j < cols; j++)\n {\n int ind = cols * i + j;\n out(ind) = M(i, j);\n }\n }\n }\n\n void ColumnIntoMatrix(const Eigen::VectorXd &v, Eigen::MatrixXd &out)\n {\n int rows = out.rows();\n int cols = out.cols();\n\n for (int i = 0; i < rows; i++)\n {\n for (int j = 0; j < cols; j++)\n {\n int ind = cols * i + j;\n out(i, j) = v(ind);\n }\n }\n }\n\n void SolveSparseSystem(const Eigen::SparseMatrix &M, Eigen::VectorXd &rhs, Eigen::VectorXd &output)\n {\n Eigen::SimplicialLDLT> solver;\n solver.compute(M);\n if (solver.info() != Eigen::Success)\n {\n // decomposition failed\n std::cout << \"Sparse decomposition failed. Exiting.\" << std::endl;\n std::exit(1);\n }\n Eigen::VectorXd x = solver.solve(rhs);\n if (solver.info() != Eigen::Success)\n {\n // solving failed\n std::cout << \"Sparse solve failed. Exiting.\" << std::endl;\n std::exit(1);\n }\n output = x;\n }\n\n void SolveDenseSystem(const Eigen::MatrixXd &M, Eigen::VectorXd &rhs, Eigen::VectorXd &output)\n {\n Eigen::PartialPivLU solver = M.partialPivLu();\n output = solver.solve(rhs);\n }\n\n void SolveDenseSystem(Eigen::PartialPivLU &solver, const Eigen::MatrixXd &M, Eigen::VectorXd &rhs, Eigen::VectorXd &output)\n {\n solver.compute(M);\n output = solver.solve(rhs);\n }\n\n } // namespace MatrixUtils\n} // namespace rsurfaces", "meta": {"hexsha": "f0d2053873fdef03748756046cd5ebf03d46f354", "size": 3100, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/matrix_utils.cpp", "max_stars_repo_name": "Conrekatsu/repulsive-surfaces", "max_stars_repo_head_hexsha": "74d6a16e6ca55c8296fa5a49757c2318bea62a84", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 35.0, "max_stars_repo_stars_event_min_datetime": "2021-12-13T09:58:08.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T11:03:01.000Z", "max_issues_repo_path": "src/matrix_utils.cpp", "max_issues_repo_name": "Conrekatsu/repulsive-surfaces", "max_issues_repo_head_hexsha": "74d6a16e6ca55c8296fa5a49757c2318bea62a84", "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/matrix_utils.cpp", "max_forks_repo_name": "Conrekatsu/repulsive-surfaces", "max_forks_repo_head_hexsha": "74d6a16e6ca55c8296fa5a49757c2318bea62a84", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2022-02-25T06:46:34.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-16T05:46:53.000Z", "avg_line_length": 32.6315789474, "max_line_length": 148, "alphanum_fraction": 0.4396774194, "num_tokens": 758, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6893056040203136, "lm_q2_score": 0.7217432182679956, "lm_q1q2_score": 0.49750164501578575}} {"text": "// #include \n// #include \n// #include \n// #include \n// \n// #include \"ParticleFilter.h\"\n// \n// using std::cout;\n// using std::endl;\n// \n// /// Randomly initialize all particles\n// int ParticleFilter::init(int num_particles, double x_min, double x_max, \n// \t double y_min, double y_max,\n// \t double heading_min, double heading_max,\n// \t double velocity_min, double velocity_max)\n// {\n// num_particles_ = num_particles;\n// \n// x_min_ = x_min;\n// x_max_ = x_max;\n// y_min_ = y_min;\n// y_max_ = y_max;\n// heading_min_ = heading_min;\n// heading_max_ = heading_max;\n// velocity_min_ = velocity_min;\n// velocity_max_ = velocity_max;\n// \n// boost::uniform_int<> x_dist(x_min_, x_max_);\n// boost::uniform_int<> y_dist(y_min_, y_max_);\n// boost::uniform_int<> heading_dist(heading_min_, heading_max_);\n// boost::uniform_int<> x_velocity_dist(velocity_min_, velocity_max_);\n// boost::uniform_int<> y_velocity_dist(velocity_min_, velocity_max_);\n// \n// for (int i = 0 ; i < num_particles_ ; i++) {\n// \t double x=0, y=0, heading=0, x_velocity=0, y_velocity;\n// \n// \t x = x_dist(gen_);\n// \t y = y_dist(gen_);\n// \t heading = heading_dist(gen_);\n// \t x_velocity = x_velocity_dist(gen_);\n// \t y_velocity = y_velocity_dist(gen_);\n// \t \n// \t cv::Point center(x,y);\n// \t cv::Point2d velocity(x_velocity,y_velocity);\n// \n// \t Particle particle(center,heading,velocity,1.0/num_particles_); \n// \t particles_.push_back(particle);\n// }\n// \n// return 0;\n// }\n// \n// /// Use motion model to update particles\n// int ParticleFilter::kinematic_step()\n// {\n// std::vector::iterator it;\n// for (it = particles_.begin(); it != particles_.end(); it++) {\n// \t it->kinematic_step();\n// }\n// return 0;\n// }\n// \n// int ParticleFilter::importance_weight_update(cv::Point target) \n// {\n// double champ = -9999;\n// double wNorm = 0;\n// std::vector::iterator it;\n// for (it = particles_.begin(); it != particles_.end(); it++) {\n// \t double w = it->importance_weight_update(target);\n// \t wNorm += w;\n// \n// \t if (w > champ) {\n// \t champ = w;\n// \t }\n// }\n// \n// wMax_ = champ;\n// \n// for (it = particles_.begin(); it != particles_.end(); it++) {\n// \t it->normalize_importance_weight(wNorm);\n// }\n// \n// return 0;\n// }\n// \n// int ParticleFilter::importance_weight_update(cv::Point target, cv::Point2d velocity) \n// {\n// double champ = -9999;\n// double wNorm = 0;\n// std::vector::iterator it;\n// for (it = particles_.begin(); it != particles_.end(); it++) {\n// \t double w = it->importance_weight_update(target, velocity);\n// \t wNorm += w;\n// \n// \t if (w > champ) {\n// \t champ = w;\n// \t }\n// }\n// \n// wMax_ = champ;\n// \n// for (it = particles_.begin(); it != particles_.end(); it++) {\n// \t it->normalize_importance_weight(wNorm);\n// }\n// \n// return 0;\n// }\n// \n// \n// \n// int ParticleFilter::resample_wheel()\n// {\n// boost::uniform_int<> index_select(0, particles_.size()-1);\n// boost::uniform_real<> beta_select(0, 2*wMax_);\n// \n// std::vector newParticles;\n// \n// int index = index_select(gen_);\n// double beta = 0;\n// \n// //std::vector::iterator it;\n// //for (it = particles_.begin(); it != particles_.end(); it++) {\n// for (int i = 0 ; i < num_particles_; i++) {\n// \t beta += beta_select(gen_);\n// \t while (beta > particles_[index].not_normalized_weight()) {\n// \t beta -= particles_[index].not_normalized_weight();\n// \t index = (index + 1) % particles_.size(); \n// \t }\n// \t \n// \t Particle part1 = particles_[index];\n// \t Particle part2 = part1;\n// \n// \t boost::uniform_int<> x1_velocity_dist(velocity_min_, velocity_max_);\n// \t boost::uniform_int<> y1_velocity_dist(velocity_min_, velocity_max_);\n// \n// \t boost::uniform_int<> x2_velocity_dist(velocity_min_, velocity_max_);\n// \t boost::uniform_int<> y2_velocity_dist(velocity_min_, velocity_max_);\n// \n// \t cv::Point2d velocity1, velocity2;\n// \t velocity1.x = x1_velocity_dist(gen_);\n// \t velocity1.y = y1_velocity_dist(gen_);\n// \n// \t velocity2.x = x2_velocity_dist(gen_);\n// \t velocity2.y = y2_velocity_dist(gen_);\n// \n// \t part1.set_velocity(velocity1);\n// \t part2.set_velocity(velocity2);\n// \n// \t newParticles.push_back(part1);\n// \t newParticles.push_back(part2);\n// }\n// particles_ = newParticles;\n// return 0;\n// }\n// \n// \n// int ParticleFilter::getParticles(std::vector &particles)\n// {\n// particles = particles_;\n// return 0;\n// }\n", "meta": {"hexsha": "e3deb9a0b8a7344776d807bb6d8675a9aa54c972", "size": 4778, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/filter/ParticleFilter.cpp", "max_stars_repo_name": "SyllogismRXS/openmht", "max_stars_repo_head_hexsha": "a29ae04907f88618a938a5eb58a950b0efcde849", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 20.0, "max_stars_repo_stars_event_min_datetime": "2017-01-09T12:21:46.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-12T16:50:02.000Z", "max_issues_repo_path": "src/filter/ParticleFilter.cpp", "max_issues_repo_name": "SyllogismRXS/openmht", "max_issues_repo_head_hexsha": "a29ae04907f88618a938a5eb58a950b0efcde849", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2016-05-27T14:55:44.000Z", "max_issues_repo_issues_event_max_datetime": "2016-05-27T14:55:44.000Z", "max_forks_repo_path": "src/filter/ParticleFilter.cpp", "max_forks_repo_name": "SyllogismRXS/openmht", "max_forks_repo_head_hexsha": "a29ae04907f88618a938a5eb58a950b0efcde849", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2016-12-09T15:52:02.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-29T14:02:06.000Z", "avg_line_length": 29.4938271605, "max_line_length": 88, "alphanum_fraction": 0.5939723734, "num_tokens": 1316, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085808877581, "lm_q2_score": 0.6334102775181399, "lm_q1q2_score": 0.4974225261574915}} {"text": "// Modified from NetKet source for YANNQ Project\n// (chae.yeun.park@gmail.com)\n// 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 YANNQ_ACTIVATIONLAYER_HH\n#define YANNQ_ACTIVATIONLAYER_HH\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \"AbstractLayer.hpp\"\n#include \"activations.hpp\"\n\n/**\n * Misc: Because of bugs in Intel C compiler (ICC), constexpr static member \n * variable of template class does not work. If there's any update in ICC \n * regarding this bug, one may update name function to return such a member\n * variable.\n * */\n\nnamespace yannq {\n\ntemplate \nclass ActivationLayer\n\t: public AbstractLayer \n{\npublic:\n\tusing Scalar = T;\n\tusing Vector = typename AbstractLayer::Vector;\n\tusing Matrix = typename AbstractLayer::Matrix;\n\tusing VectorRef = typename AbstractLayer::VectorRef;\n\tusing VectorConstRef = typename AbstractLayer::VectorConstRef;\n\nprivate:\n\n\tActivation f_; \n\npublic:\n\tActivationLayer()\n\t{\n\t}\n\n\ttemplate::type>::type,\n ActivationLayer\n\t\t\t>::value, int>::type = 0>\n\tActivationLayer(Ts&&... args)\n\t\t: f_(std::forward(args)...)\n\t{\n\t}\n\n\tActivationLayer(const ActivationLayer&) = default;\n\tActivationLayer(ActivationLayer&&) = default;\n\t\n\tActivationLayer& operator=(const ActivationLayer&) = default;\n\tActivationLayer& operator=(ActivationLayer&&) = default;\n\t\n\tstd::string name() const override \n\t{\n\t\treturn std::string(\"Activation Layer\");\n\t}\n\t\n\tbool operator==(const ActivationLayer& rhs) const\n\t{\n\t\treturn f_.name() == rhs.f_.name();\n\t}\n\n\tuint32_t paramDim() const override { return 0; }\n\n\tVector getParams() const override\n\t{\n\t\treturn Vector{};\n\t}\n\n\tvoid setParams(VectorConstRef pars) override\n\t{\n\t\t(void)pars;\n\t}\n\n\tuint32_t outputDim(uint32_t inputDim) const override \n\t{\n\t\treturn inputDim; \n\t}\n\n\t// Feedforward\n\tvoid forward(const VectorConstRef& input, VectorRef output) override \n\t{\n\t\tassert(input.size() == output.size());\n\t\tf_.operator()(input, output);\n\t}\n\n\t// Computes derivative.\n\tvoid backprop(const VectorConstRef& prev_layer_output,\n\t\t\tconst VectorConstRef& this_layer_output,\n\t\t\tconst VectorConstRef& dout,\n\t\t\tVectorRef din, VectorRef /*der*/) override \n\t{\n\t\tdin.resize(prev_layer_output.size());\n\t\tf_.ApplyJacobian(prev_layer_output, this_layer_output, dout, din);\n\t}\n\n\tnlohmann::json desc() const override\n\t{\n\t\tnlohmann::json layerpar;\n\t\tlayerpar[\"name\"] = name();\n\t\tlayerpar[\"activation\"] = f_.name();\n\n\t\treturn layerpar;\n\t}\n\n\ttemplate\n\tvoid serialize(Archive& ar)\n\t{\n\t\tar(f_);\n\t}\n};\n\ntemplate\nusing Identity = ActivationLayer >;\n\ntemplate\nusing LnCosh = ActivationLayer >;\n\ntemplate\nusing Tanh = ActivationLayer >;\n\ntemplate\nusing WeakTanh = ActivationLayer >;\n\ntemplate\nusing Sigmoid = ActivationLayer >;\n\ntemplate\nusing ReLU = ActivationLayer >;\n\ntemplate\nusing LeakyReLU = ActivationLayer >;\n\ntemplate\nusing HardTanh = ActivationLayer >;\n\ntemplate\nusing SoftShrink = ActivationLayer >;\n\ntemplate\nusing LeakyHardTanh = ActivationLayer >;\n\ntemplate\nusing SoftSign = ActivationLayer >;\n\ntemplate\nusing Cos = ActivationLayer >;\n\n} // namespace yannq\n\n#endif\n", "meta": {"hexsha": "08c743cc910e68501ff06541e636d6852db89eb8", "size": 4401, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "Yannq/Machines/layers/ActivationLayer.hpp", "max_stars_repo_name": "cecri/yannq", "max_stars_repo_head_hexsha": "b78c1f86a255059f06b34dd5e538449e7261d0ee", "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": "Yannq/Machines/layers/ActivationLayer.hpp", "max_issues_repo_name": "cecri/yannq", "max_issues_repo_head_hexsha": "b78c1f86a255059f06b34dd5e538449e7261d0ee", "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": "Yannq/Machines/layers/ActivationLayer.hpp", "max_forks_repo_name": "cecri/yannq", "max_forks_repo_head_hexsha": "b78c1f86a255059f06b34dd5e538449e7261d0ee", "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": 24.8644067797, "max_line_length": 92, "alphanum_fraction": 0.7252897069, "num_tokens": 1090, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837635542924, "lm_q2_score": 0.6513548782017746, "lm_q1q2_score": 0.4972988738189386}} {"text": "#ifndef STAN_MATH_PRIM_MAT_FUN_MDIVIDE_LEFT_TRI_HPP\n#define STAN_MATH_PRIM_MAT_FUN_MDIVIDE_LEFT_TRI_HPP\n\n#include \n#include \n#include \n#include \n#include \n#ifdef STAN_OPENCL\n#include \n#include \n#include \n#include \n#include \n#endif\nnamespace stan {\nnamespace math {\n\n/**\n * Returns the solution of the system Ax=b when A is triangular.\n * @tparam TriView Specifies whether A is upper (Eigen::Upper)\n * or lower triangular (Eigen::Lower).\n * @tparam T1 type of elements in A\n * @tparam T2 type of elements in b\n * @tparam R1 number of rows in A\n * @tparam C1 number of columns in A\n * @tparam R2 number of rows in b\n * @tparam C2 number of columns in b\n * @param A Triangular matrix.\n * @param b Right hand side matrix or vector.\n * @return x = A^-1 b, solution of the linear system.\n * @throws std::domain_error if A is not square or the rows of b don't\n * match the size of A.\n */\ntemplate \ninline Eigen::Matrix::type,\n R1, C2>\nmdivide_left_tri(const Eigen::Matrix &A,\n const Eigen::Matrix &b) {\n check_square(\"mdivide_left_tri\", \"A\", A);\n check_multiplicable(\"mdivide_left_tri\", \"A\", A, \"b\", b);\n return promote_common, Eigen::Matrix >(\n A)\n .template triangularView()\n .solve(\n promote_common, Eigen::Matrix >(\n b));\n}\n\n/**\n * Returns the solution of the system Ax=b when A is triangular and b=I.\n * @tparam T type of elements in A\n * @tparam R1 number of rows in A\n * @tparam C1 number of columns in A\n * @param A Triangular matrix.\n * @return x = A^-1 .\n * @throws std::domain_error if A is not square\n */\ntemplate \ninline Eigen::Matrix mdivide_left_tri(\n const Eigen::Matrix &A) {\n check_square(\"mdivide_left_tri\", \"A\", A);\n int n = A.rows();\n Eigen::Matrix b;\n b.setIdentity(n, n);\n A.template triangularView().solveInPlace(b);\n return b;\n}\n\n/**\n * Returns the solution of the system Ax=b when A is triangular\n * and A and b are matrices of doubles.\n * @tparam TriView Specifies whether A is upper (Eigen::Upper)\n * or lower triangular (Eigen::Lower).\n * @tparam R1 number of rows in A\n * @tparam C1 number of columns in A\n * @tparam R2 number of rows in b\n * @tparam C2 number of columns in b\n * @param A Triangular matrix.\n * @param b Right hand side matrix or vector.\n * @return x = A^-1 b, solution of the linear system.\n * @throws std::domain_error if A is not square or the rows of b don't\n * match the size of A.\n */\ntemplate \ninline Eigen::Matrix mdivide_left_tri(\n const Eigen::Matrix &A,\n const Eigen::Matrix &b) {\n check_square(\"mdivide_left_tri\", \"A\", A);\n check_multiplicable(\"mdivide_left_tri\", \"A\", A, \"b\", b);\n#ifdef STAN_OPENCL\n if (A.rows()\n >= opencl_context.tuning_opts().tri_inverse_size_worth_transfer) {\n matrix_cl A_cl(A);\n matrix_cl b_cl(b);\n matrix_cl A_inv_cl(A.rows(), A.cols());\n if (TriView == Eigen::Lower) {\n A_inv_cl = tri_inverse(A_cl);\n } else {\n A_inv_cl = tri_inverse(A_cl);\n }\n matrix_cl C_cl = A_inv_cl * b_cl;\n return from_matrix_cl(C_cl);\n } else {\n#endif\n return A.template triangularView().solve(b);\n#ifdef STAN_OPENCL\n }\n#endif\n}\n\n/**\n * Returns the solution of the system Ax=b when A is triangular, b=I and\n * both are matrices of doubles.\n * @tparam TriView Specifies whether A is upper (Eigen::Upper)\n * or lower triangular (Eigen::Lower).\n * @tparam R1 number of rows in A\n * @tparam C1 number of columns in A\n * @param A Triangular matrix.\n * @return x = A^-1 .\n * @throws std::domain_error if A is not square\n */\ntemplate \ninline Eigen::Matrix mdivide_left_tri(\n const Eigen::Matrix &A) {\n check_square(\"mdivide_left_tri\", \"A\", A);\n const int n = A.rows();\n#ifdef STAN_OPENCL\n if (A.rows()\n >= opencl_context.tuning_opts().tri_inverse_size_worth_transfer) {\n matrix_cl A_cl(A);\n if (TriView == Eigen::Lower) {\n A_cl = tri_inverse(A_cl);\n } else {\n A_cl = tri_inverse(A_cl);\n }\n return from_matrix_cl(A_cl);\n } else {\n#endif\n Eigen::Matrix b;\n b.setIdentity(n, n);\n A.template triangularView().solveInPlace(b);\n return b;\n#ifdef STAN_OPENCL\n }\n#endif\n}\n\n} // namespace math\n} // namespace stan\n#endif\n", "meta": {"hexsha": "336b4fa6bb374487d1c6e2e1bd8fbeae6f2e5b4e", "size": 5161, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "stan/math/prim/mat/fun/mdivide_left_tri.hpp", "max_stars_repo_name": "riddell-stan/math", "max_stars_repo_head_hexsha": "d84ee0d991400d6cf4b08a07a4e8d86e0651baea", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-07-23T14:57:41.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-23T14:57:41.000Z", "max_issues_repo_path": "stan/math/prim/mat/fun/mdivide_left_tri.hpp", "max_issues_repo_name": "Capri2014/math", "max_issues_repo_head_hexsha": "d4042bdf8623bba5a1633b557227325a324e32e9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2019-09-23T19:58:36.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-24T12:03:41.000Z", "max_forks_repo_path": "stan/math/prim/mat/fun/mdivide_left_tri.hpp", "max_forks_repo_name": "riddell-stan/math", "max_forks_repo_head_hexsha": "d84ee0d991400d6cf4b08a07a4e8d86e0651baea", "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.9539473684, "max_line_length": 80, "alphanum_fraction": 0.6828134083, "num_tokens": 1499, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434978390747, "lm_q2_score": 0.6442251201477016, "lm_q1q2_score": 0.49724097013060015}} {"text": "/*\n * Copyright (c) 2019, The Robot Studio\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 *\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 * * 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 *\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 ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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 OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n/**\n * @file arm_transform.cpp\n * @author Cyril Jourdan\n * @date Sep 26, 2017\n * @version 0.1.0\n * @brief Implementation file for the arm transform\n *\n * Contact: contact@therobotstudio.com\n * Created on : Jul 17, 2012\n */\n\n#include \n#include \n#include \n#include \n//#include \n#include \"std_msgs/Int16.h\"\n#include \n\n#include \n\nusing namespace std;\n\ndouble calculateAlpha(tf::StampedTransform tf_hand, tf::StampedTransform tf_elbow, tf::StampedTransform tf_shoulder)\n{\n\tdouble rightHand[3] = {tf_hand.getOrigin().x(), tf_hand.getOrigin().y(), tf_hand.getOrigin().z()};\n\tdouble rightElbow[3] = {tf_elbow.getOrigin().x(), tf_elbow.getOrigin().y(), tf_elbow.getOrigin().z()};\n\tdouble rightShoulder[3] = {tf_shoulder.getOrigin().x(), tf_shoulder.getOrigin().y(), tf_shoulder.getOrigin().z()};\n\n\t//Al-Kashi triangle formula\n\tdouble num = pow(rightHand[0]-rightElbow[0], 2) + pow(rightHand[1]-rightElbow[1], 2) + pow(rightHand[2]-rightElbow[2], 2)\n\t\t\t\t+ pow(rightShoulder[0]-rightElbow[0], 2) + pow(rightShoulder[1]-rightElbow[1], 2) + pow(rightShoulder[2]-rightElbow[2], 2)\n\t\t\t\t- pow(rightShoulder[0]-rightHand[0], 2) - pow(rightShoulder[1]-rightHand[1], 2) - pow(rightShoulder[2]-rightHand[2], 2);\n\n\tdouble den = 2 * sqrt(pow(rightHand[0]-rightElbow[0], 2) + pow(rightHand[1]-rightElbow[1], 2) + pow(rightHand[2]-rightElbow[2], 2)) * sqrt(pow(rightShoulder[0]-rightElbow[0], 2) + pow(rightShoulder[1]-rightElbow[1], 2) + pow(rightShoulder[2]-rightElbow[2], 2));\n\n\treturn acos(num/den);\n}\n\ndouble calculateBeta(tf::StampedTransform tf_elbow, tf::StampedTransform tf_neck, tf::StampedTransform tf_shoulder)\n{\n\tdouble rightElbow[3] = {tf_elbow.getOrigin().x(), tf_elbow.getOrigin().y(), tf_elbow.getOrigin().z()};\n\tdouble neck[3] = {tf_neck.getOrigin().x(), tf_neck.getOrigin().y(), tf_neck.getOrigin().z()};\n\tdouble rightShoulder[3] = {tf_shoulder.getOrigin().x(), tf_shoulder.getOrigin().y(), tf_shoulder.getOrigin().z()};\n\n\t//Al-Kashi triangle formula\n\tdouble num = pow(rightElbow[0]-rightShoulder[0], 2) + pow(rightElbow[1]-rightShoulder[1], 2) + pow(rightElbow[2]-rightShoulder[2], 2)\n\t\t\t\t\t\t+ pow(rightShoulder[0]-neck[0], 2) + pow(rightShoulder[1]-neck[1], 2) + pow(rightShoulder[2]-neck[2], 2)\n\t\t\t\t\t\t- pow(neck[0]-rightElbow[0], 2) - pow(neck[1]-rightElbow[1], 2) - pow(neck[2]-rightElbow[2], 2);\n\n\tdouble den = 2 * sqrt(pow(rightElbow[0]-rightShoulder[0], 2) + pow(rightElbow[1]-rightShoulder[1], 2) + pow(rightElbow[2]-rightShoulder[2], 2)) * sqrt(pow(rightShoulder[0]-neck[0], 2) + pow(rightShoulder[1]-neck[1], 2) + pow(rightShoulder[2]-neck[2], 2));\n\n\treturn acos(num/den);\n}\n\ndouble calculateTheta(tf::StampedTransform tf_elbow, tf::StampedTransform tf_neck, tf::StampedTransform tf_shoulder, tf::StampedTransform tf_torso)\n{\n\tdouble rightElbow[3] = {tf_elbow.getOrigin().x(), tf_elbow.getOrigin().y(), tf_elbow.getOrigin().z()};\n\tdouble neck[3] = {tf_neck.getOrigin().x(), tf_neck.getOrigin().y(), tf_neck.getOrigin().z()};\n\tdouble rightShoulder[3] = {tf_shoulder.getOrigin().x(), tf_shoulder.getOrigin().y(), tf_shoulder.getOrigin().z()};\n\tdouble torso[3] = {tf_torso.getOrigin().x(), tf_torso.getOrigin().y(), tf_torso.getOrigin().z()};\n\n\t////Theta is the angle between two planes : TNE and SNE\n\tdouble a1 = (rightShoulder[1]-torso[1])*(neck[2]-torso[2]) - (rightShoulder[2]-torso[2])*(neck[1]-torso[1]);\n\tdouble b1 = (rightShoulder[2]-torso[2])*(neck[0]-torso[0]) - (rightShoulder[0]-torso[0])*(neck[2]-torso[2]);\n\tdouble c1 = (rightShoulder[0]-torso[0])*(neck[1]-torso[1]) - (rightShoulder[1]-torso[1])*(neck[0]-torso[0]);\n\n\tdouble a2 = (rightShoulder[1]-rightElbow[1])*(neck[2]-rightElbow[2]) - (rightShoulder[2]-rightElbow[2])*(neck[1]-rightElbow[1]);\n\tdouble b2 = (rightShoulder[2]-rightElbow[2])*(neck[0]-rightElbow[0]) - (rightShoulder[0]-rightElbow[0])*(neck[2]-rightElbow[2]);\n\tdouble c2 = (rightShoulder[0]-rightElbow[0])*(neck[1]-rightElbow[1]) - (rightShoulder[1]-rightElbow[1])*(neck[0]-rightElbow[0]);\n\n\tdouble num = a1*a2 + b1*b2 + c1*c2;\n\n\tdouble den = sqrt((a1*a1+b1*b1+c1*c1)*(a2*a2+b2*b2+c2*c2));\n\n\treturn acos(num/den);\n}\n\ndouble calculatePhi(tf::StampedTransform tf_hand, tf::StampedTransform tf_neck, tf::StampedTransform tf_shoulder, tf::StampedTransform tf_elbow)\n{\n\tdouble H[3] = {tf_hand.getOrigin().x(), tf_hand.getOrigin().y(), tf_hand.getOrigin().z()};\n\tdouble N[3] = {tf_neck.getOrigin().x(), tf_neck.getOrigin().y(), tf_neck.getOrigin().z()};\n\tdouble S[3] = {tf_shoulder.getOrigin().x(), tf_shoulder.getOrigin().y(), tf_shoulder.getOrigin().z()};\n\tdouble E[3] = {tf_elbow.getOrigin().x(), tf_elbow.getOrigin().y(), tf_elbow.getOrigin().z()};\n\n\t//Phi is the angle between two planes : SNE and SHE\n\tfloat n1[3] = {(N[1]-S[1])*(E[2]-S[2])-(N[2]-S[2])*(E[1]-S[1]),\n\t\t\t\t\t(N[2]-S[2])*(E[0]-S[0])-(N[0]-S[0])*(E[2]-S[2]),\n\t\t\t\t\t(N[0]-S[0])*(E[1]-S[1])-(N[1]-S[1])*(E[0]-S[0])}; //normal plane vector : SNE\n\n\tfloat n2[3] = {(H[1]-S[1])*(E[2]-S[2])-(H[2]-S[2])*(E[1]-S[1]),\n\t\t\t\t\t\t(H[2]-S[2])*(E[0]-S[0])-(H[0]-S[0])*(E[2]-S[2]),\n\t\t\t\t\t\t(H[0]-S[0])*(E[1]-S[1])-(H[1]-S[1])*(E[0]-S[0])}; //normal plane vector : SHE\n\n\tfloat a1,b1,c1;\n\ta1 = n1[0];\n\tb1 = n1[1];\n\tc1 = n1[2];\n\n\tfloat a2,b2,c2;\n\ta2 = n2[0];\n\tb2 = n2[1];\n\tc2 = n2[2];\n\n\tdouble angle_phi = acos(fabs((a1*a2 + b1*b2 + c1*c2)/(sqrt((a1*a1+b1*b1+c1*c1)*(a2*a2+b2*b2+c2*c2)))));\n\n\t//std::cerr << \"angle_phi\" << angle_phi << std::endl;\n\n\treturn angle_phi;\n\n\t//right\n\t/*\n\tdouble a1 = (rightShoulder[1]-rightHand[1])*(rightElbow[2]-rightHand[2]) - (rightShoulder[2]-rightHand[2])*(rightElbow[1]-rightHand[1]);\n\tdouble b1 = (rightShoulder[2]-rightHand[2])*(rightElbow[0]-rightHand[0]) - (rightShoulder[0]-rightHand[0])*(rightElbow[2]-rightHand[2]);\n\tdouble c1 = (rightShoulder[0]-rightHand[0])*(rightElbow[1]-rightHand[1]) - (rightShoulder[1]-rightHand[1])*(rightElbow[0]-rightHand[0]);\n\n\tdouble a2 = (rightShoulder[1]-rightHand[1])*(neck[2]-rightHand[2]) - (rightShoulder[2]-rightHand[2])*(neck[1]-rightHand[1]);\n\tdouble b2 = (rightShoulder[2]-rightHand[2])*(neck[0]-rightHand[0]) - (rightShoulder[0]-rightHand[0])*(neck[2]-rightHand[2]);\n\tdouble c2 = (rightShoulder[0]-rightHand[0])*(neck[1]-rightHand[1]) - (rightShoulder[1]-rightHand[1])*(neck[0]-rightHand[0]);\n\n\tdouble num = a1*a2 + b1*b2 + c1*c2;\n\n\tdouble den = sqrt((a1*a1+b1*b1+c1*c1)*(a2*a2+b2*b2+c2*c2));\n\n\treturn acos(num/den);\n\t*/\n}\n/*\ndouble calculateLambda(tf::StampedTransform tf_hand, tf::StampedTransform tf_elbow, tf::StampedTransform tf_shoulder)\n{\n\tdouble leftHand[3] = {tf_hand.getOrigin().x(), tf_hand.getOrigin().y(), tf_hand.getOrigin().z()};\n\tdouble leftElbow[3] = {tf_elbow.getOrigin().x(), tf_elbow.getOrigin().y(), tf_elbow.getOrigin().z()};\n\tdouble leftShoulder[3] = {tf_shoulder.getOrigin().x(), tf_shoulder.getOrigin().y(), tf_shoulder.getOrigin().z()};\n\n\t//Al-Kashi triangle formula\n\tdouble num = pow(rightHand[0]-rightElbow[0], 2) + pow(rightHand[1]-rightElbow[1], 2) + pow(rightHand[2]-rightElbow[2], 2)\n\t\t\t\t+ pow(rightShoulder[0]-rightElbow[0], 2) + pow(rightShoulder[1]-rightElbow[1], 2) + pow(rightShoulder[2]-rightElbow[2], 2)\n\t\t\t\t- pow(rightShoulder[0]-rightHand[0], 2) - pow(rightShoulder[1]-rightHand[1], 2) - pow(rightShoulder[2]-rightHand[2], 2);\n\n\tdouble den = 2 * sqrt(pow(rightHand[0]-rightElbow[0], 2) + pow(rightHand[1]-rightElbow[1], 2) + pow(rightHand[2]-rightElbow[2], 2)) * sqrt(pow(rightShoulder[0]-rightElbow[0], 2) + pow(rightShoulder[1]-rightElbow[1], 2) + pow(rightShoulder[2]-rightElbow[2], 2));\n\n\treturn acos(num/den);\n}\n*/\n//sensor_msgs::JointState prev_joint_state;\n/*\nstring playerNb_str = \"1\";\nstring frame_str = \"/openni_depth_frame\";\n*/\nstring playerNb_str = \"0\";\nstring frame_str = \"/camera_depth_optical_frame\";\n/*\nvoid playerNumber_cb(const std_msgs::Int16ConstPtr& number)\n{\n\tplayerNb_str = boost::lexical_cast(number->data);\n\n\t//ROS_INFO(\"Player Number is %s\", playerNb_str);\n\t//cout << \"number = \" << playerNb_str << endl;\n\tROS_INFO(\"number = %d\", number->data);\n\n\tif(number->data == 0)\n\t{\n\t\tframe_str = \"/camera_depth_optical_frame\";\n\t}\n\telse\n\t{\n\t\tframe_str = \"/openni_depth_frame\";\n\t}\n}\n*/\nint main(int argc, char** argv)\n{\n\tros::init(argc, argv, \"arm_transform\");\n\tros::NodeHandle n;\n\tros::Publisher joint_pub = n.advertise(\"joint_states_kinect\", 100);\n\tros::Publisher test_pub = n.advertise(\"/test\", 1);\n\n\tros::Rate loop_rate(50);\n\t//ros::Rate loop_rate(10);\n\n\ttf::TransformListener listener_neck, listener_torso, listener_shoulder, listener_elbow, listener_hand;\n\ttf::StampedTransform transform_neck, transform_torso, transform_shoulder, transform_elbow, transform_hand;\n\n\t//left part\n\ttf::TransformListener listener_leftShoulder, listener_leftElbow, listener_leftHand;\n\ttf::StampedTransform transform_leftShoulder, transform_leftElbow, transform_leftHand;\n\n\t//read the player number : 0 used for the posture generated by IR markers, other numbers used by openni_tracker\n\t//ros::Subscriber sub_playerNumber = n.subscribe(\"/playerNumber\", 1, &playerNumber_cb);\n\n\tbool error = false;\n\n\t//tf::TransformBroadcaster transform;\n\t//transform.sendTransform(tf::StampedTransform(null, ros::Time::now(), ));\n\n\t// message declarations\n\tsensor_msgs::JointState joint_state;\n/*\n\t//init joint state\n\t//update joint_state\n\tjoint_state.header.stamp = ros::Time::now();\n\tjoint_state.name.resize(6);\n\tjoint_state.position.resize(6);\n\tjoint_state.name[0] =\"elbow_alpha_joint\";\n\tjoint_state.position[0] = M_PI/2;\n\tjoint_state.name[1] =\"shoulder_beta_joint\";\n\tjoint_state.position[1] = M_PI/2;\n\tjoint_state.name[2] =\"shoulder_theta_joint\";\n\tjoint_state.position[2] = M_PI/2;\n\tjoint_state.name[3] =\"shoulder_phi_joint\";\n\tjoint_state.position[3] = 3*M_PI/4;\n\tjoint_state.name[4] =\"elbow_twist_joint\";\n\tjoint_state.position[4] = M_PI/2;\n\tjoint_state.name[5] =\"wrist_joint\";\n\tjoint_state.position[5] = M_PI/2;\n\n\tprev_joint_state = joint_state;\n*/\n\t//uint32_t begin, end, loopTime;\n\n\twhile (ros::ok())\n\t{/*\n\t\tbegin = ros::WallTime::now().nsec;\n\t\terror = false;\n*/\n\n\n\t\t//grab tf skeleton joints\n\t\ttry\n\t\t{\n\t\t\tlistener_neck.lookupTransform(frame_str, \"/neck_\" + playerNb_str, ros::Time(0), transform_neck);\n\t\t}\n\t\tcatch (tf::TransformException ex)\n\t\t{\n\t\t\t//ROS_ERROR(\"%s\",ex.what());\n\t\t\terror = true;\n\t\t}\n\n\t\ttry\n\t\t{\n\t\t\tlistener_torso.lookupTransform(frame_str, \"/torso_\" + playerNb_str, ros::Time(0), transform_torso);\n\t\t}\n\t\tcatch (tf::TransformException ex)\n\t\t{\n\t\t\t//ROS_ERROR(\"%s\",ex.what());\n\t\t\terror = true;\n\t\t}\n\n\t\ttry\n\t\t{\n\t\t\tlistener_shoulder.lookupTransform(frame_str, \"/left_shoulder_\" + playerNb_str, ros::Time(0), transform_shoulder);\n\t\t}\n\t\tcatch (tf::TransformException ex)\n\t\t{\n\t\t\t//ROS_ERROR(\"%s\",ex.what());\n\t\t\terror = true;\n\t\t}\n\n\t\ttry\n\t\t{\n\t\t\tlistener_elbow.lookupTransform(frame_str, \"/left_elbow_\" + playerNb_str, ros::Time(0), transform_elbow);\n\t\t}\n\t\tcatch (tf::TransformException ex)\n\t\t{\n\t\t\t//ROS_ERROR(\"%s\",ex.what());\n\t\t\terror = true;\n\t\t}\n\n\t\ttry\n\t\t{\n\t\t\tlistener_hand.lookupTransform(frame_str, \"/left_hand_\" + playerNb_str, ros::Time(0), transform_hand);\n\t\t}\n\t\tcatch (tf::TransformException ex)\n\t\t{\n\t\t\t//ROS_ERROR(\"%s\",ex.what());\n\t\t\terror = true;\n\t\t}\n/*\n\t\t//get the left arm transform\n\t\ttry\n\t\t{\n\t\t\tlistener_leftShoulder.lookupTransform(frame_str, \"/right_shoulder_\" + playerNb_str, ros::Time(0), transform_leftShoulder);\n\t\t}\n\t\tcatch (tf::TransformException ex)\n\t\t{\n\t\t\t//ROS_ERROR(\"%s\",ex.what());\n\t\t\terror = true;\n\t\t}\n\n\t\ttry\n\t\t{\n\t\t\tlistener_leftElbow.lookupTransform(frame_str, \"/right_elbow_\" + playerNb_str, ros::Time(0), transform_leftElbow);\n\t\t}\n\t\tcatch (tf::TransformException ex)\n\t\t{\n\t\t\t//ROS_ERROR(\"%s\",ex.what());\n\t\t\terror = true;\n\t\t}\n\n\t\ttry\n\t\t{\n\t\t\tlistener_leftHand.lookupTransform(frame_str, \"/right_hand_\" + playerNb_str, ros::Time(0), transform_leftHand);\n\t\t}\n\t\tcatch (tf::TransformException ex)\n\t\t{\n\t\t\t//ROS_ERROR(\"%s\",ex.what());\n\t\t\terror = true;\n\t\t}\n*/\n\t\t//ROS_INFO(\"transform_han %f\", transform_hand.getOrigin().x());\n\n\t\t//update joint_state\n\t\tjoint_state.header.stamp = ros::Time::now();\n\t\tjoint_state.name.resize(4);//6\n\t\tjoint_state.position.resize(4);//6\n\t\tjoint_state.name[0] =\"elbow_alpha_joint\";\n\t\tjoint_state.position[0] = M_PI - calculateAlpha(transform_hand, transform_elbow, transform_shoulder);\n\t\tjoint_state.name[1] =\"shoulder_beta_joint\";\n\t\tjoint_state.position[1] = M_PI - calculateBeta(transform_elbow, transform_neck, transform_shoulder);\n\t\tjoint_state.name[2] =\"shoulder_theta_joint\";\n\t\tjoint_state.position[2] = calculateTheta(transform_elbow, transform_neck, transform_shoulder, transform_torso) - M_PI/2;\n\t\tjoint_state.name[3] =\"shoulder_phi_joint\";\n\t\tjoint_state.position[3] = calculatePhi(transform_hand, transform_neck, transform_shoulder, transform_elbow);\n\n\t\t/*\n\t\tjoint_state.name[4] =\"elbow_twist_joint\";\n\t\tjoint_state.position[4] = 2*calculatePhi(transform_leftHand, transform_neck, transform_leftShoulder, transform_leftElbow) - 3*M_PI/4;\n\t\tjoint_state.name[5] =\"wrist_joint\";\n\t\tjoint_state.position[5] = M_PI - calculateAlpha(transform_leftHand, transform_leftElbow, transform_leftShoulder);\n*/\n\t\t//test\n\t\tstd_msgs::Float32 test;\n\t\ttest.data = M_PI;//(float)transform_hand.getOrigin().x();\n\n\t\ttest_pub.publish(test);\n\n\t\t//send the joint state and transform\n\t\tjoint_pub.publish(joint_state);\n/*\n\t\t\tprev_joint_state = joint_state;\n\t\t}\n\t\telse\n\t\t{\n\t\t\t//std::cerr << \"Error\" << std::endl;\n\t\t\tjoint_pub.publish(prev_joint_state);\n\t\t}\n*/\n\n\t\tros::spinOnce(); //reasign a new player if need\n\n\t\t// This will adjust as needed per iteration\n\t\tloop_rate.sleep();\n\n\t\t//if(error) ROS_INFO(\"Error !!!\");\n/*\n\t\tend = ros::WallTime::now().nsec;\n\t\tloopTime = end - begin;\n\t\tROS_INFO(\"loopTime = %d\", loopTime);\n\t*/\n\t}\n\n\treturn 0;\n}\n\n", "meta": {"hexsha": "6db5d903f138ed4d0a824611c505d67576259a99", "size": 15208, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/arm_transform.cpp", "max_stars_repo_name": "TheRobotStudio/osa_control", "max_stars_repo_head_hexsha": "cab89793ae64b9c5b49c2b0b31a84fe2ec3b7f5c", "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/arm_transform.cpp", "max_issues_repo_name": "TheRobotStudio/osa_control", "max_issues_repo_head_hexsha": "cab89793ae64b9c5b49c2b0b31a84fe2ec3b7f5c", "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/arm_transform.cpp", "max_forks_repo_name": "TheRobotStudio/osa_control", "max_forks_repo_head_hexsha": "cab89793ae64b9c5b49c2b0b31a84fe2ec3b7f5c", "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": 38.5989847716, "max_line_length": 262, "alphanum_fraction": 0.6949631773, "num_tokens": 4910, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434978390746, "lm_q2_score": 0.6442251201477015, "lm_q1q2_score": 0.4972409701306}} {"text": "#ifndef STAN_MATH_PRIM_MAT_PROB_CATEGORICAL_LPMF_HPP\n#define STAN_MATH_PRIM_MAT_PROB_CATEGORICAL_LPMF_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 {\n namespace math {\n\n // Categorical(n|theta) [0 < n <= N; 0 <= theta[n] <= 1; SUM theta = 1]\n template \n typename boost::math::tools::promote_args::type\n categorical_lpmf(int n,\n const Eigen::Matrix& theta) {\n static const char* function(\"categorical_lpmf\");\n\n using boost::math::tools::promote_args;\n using std::log;\n\n int lb = 1;\n\n check_bounded(function, \"Number of categories\", n, lb, theta.size());\n check_simplex(function, \"Probabilities parameter\", theta);\n\n if (include_summand::value)\n return log(theta(n - 1));\n return 0.0;\n }\n\n template \n inline\n typename boost::math::tools::promote_args::type\n categorical_lpmf(const typename\n math::index_type >::type n,\n const Eigen::Matrix& theta) {\n return categorical_lpmf(n, theta);\n }\n\n template \n typename boost::math::tools::promote_args::type\n categorical_lpmf(const std::vector& ns,\n const Eigen::Matrix& theta) {\n static const char* function(\"categorical_lpmf\");\n\n using boost::math::tools::promote_args;\n using std::log;\n\n int lb = 1;\n\n for (size_t i = 0; i < ns.size(); ++i)\n check_bounded(function, \"element of outcome array\", ns[i],\n lb, theta.size());\n\n check_simplex(function, \"Probabilities parameter\", theta);\n\n if (!include_summand::value)\n return 0.0;\n\n if (ns.size() == 0)\n return 0.0;\n\n Eigen::Matrix log_theta(theta.size());\n for (int i = 0; i < theta.size(); ++i)\n log_theta(i) = log(theta(i));\n\n Eigen::Matrix::type,\n Eigen::Dynamic, 1> log_theta_ns(ns.size());\n for (size_t i = 0; i < ns.size(); ++i)\n log_theta_ns(i) = log_theta(ns[i] - 1);\n\n return sum(log_theta_ns);\n }\n\n template \n inline\n typename boost::math::tools::promote_args::type\n categorical_lpmf(const std::vector& ns,\n const Eigen::Matrix& theta) {\n return categorical_lpmf(ns, theta);\n }\n\n }\n}\n#endif\n", "meta": {"hexsha": "bd8459f26fe4bdfebe8bb49b0e9e0f8bc7e2859a", "size": 3205, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "cmdstan/stan/lib/stan_math/stan/math/prim/mat/prob/categorical_lpmf.hpp", "max_stars_repo_name": "yizhang-cae/torsten", "max_stars_repo_head_hexsha": "dc82080ca032325040844cbabe81c9a2b5e046f9", "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": "cmdstan/stan/lib/stan_math/stan/math/prim/mat/prob/categorical_lpmf.hpp", "max_issues_repo_name": "yizhang-cae/torsten", "max_issues_repo_head_hexsha": "dc82080ca032325040844cbabe81c9a2b5e046f9", "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": "cmdstan/stan/lib/stan_math/stan/math/prim/mat/prob/categorical_lpmf.hpp", "max_forks_repo_name": "yizhang-cae/torsten", "max_forks_repo_head_hexsha": "dc82080ca032325040844cbabe81c9a2b5e046f9", "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.7040816327, "max_line_length": 79, "alphanum_fraction": 0.631825273, "num_tokens": 847, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718435083355188, "lm_q2_score": 0.6442251064863697, "lm_q1q2_score": 0.49724096634826276}} {"text": "// MIT License\n//\n// Copyright (c) 2020 Lennart Braun\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#include \"tensor_op.h\"\n\n#include \n#include \n\nnamespace MOTION::tensor {\n\nbool Conv2DOp::verify() const noexcept {\n bool result = true;\n result = result && (output_shape_ == compute_output_shape());\n result = result && strides_[0] > 0 && strides_[1] > 0;\n // maybe add more checks here\n return result;\n}\n\nstd::array Conv2DOp::compute_output_shape() const noexcept {\n const auto compute_output_dimension = [](auto input_size, auto kernel_size, auto padding_begin,\n auto padding_end, auto stride) {\n assert(stride != 0);\n return (input_size - kernel_size + padding_begin + padding_end + stride) / stride;\n };\n\n std::array output_shape;\n output_shape[0] = kernel_shape_[0];\n output_shape[1] =\n compute_output_dimension(input_shape_[1], kernel_shape_[2], pads_[0], pads_[2], strides_[0]);\n output_shape[2] =\n compute_output_dimension(input_shape_[2], kernel_shape_[3], pads_[1], pads_[3], strides_[1]);\n return output_shape;\n}\n\nstd::size_t Conv2DOp::compute_output_size() const noexcept {\n assert(verify());\n auto output_shape = compute_output_shape();\n return output_shape[0] * output_shape[1] * output_shape[2];\n}\n\nstd::size_t Conv2DOp::compute_input_size() const noexcept {\n assert(verify());\n return input_shape_[0] * input_shape_[1] * input_shape_[2];\n}\n\nstd::size_t Conv2DOp::compute_kernel_size() const noexcept {\n assert(verify());\n return kernel_shape_[0] * kernel_shape_[1] * kernel_shape_[2] * kernel_shape_[3];\n}\n\nstd::size_t Conv2DOp::compute_bias_size() const noexcept {\n assert(verify());\n return kernel_shape_[0];\n}\n\nstd::pair Conv2DOp::compute_input_matrix_shape() const noexcept {\n assert(verify());\n std::size_t num_rows = kernel_shape_[1] * kernel_shape_[2] * kernel_shape_[3];\n std::size_t num_columns = output_shape_[1] * output_shape_[2];\n return {num_rows, num_columns};\n}\n\nstd::pair Conv2DOp::compute_kernel_matrix_shape() const noexcept {\n assert(verify());\n std::size_t num_rows = kernel_shape_[0];\n std::size_t num_columns = kernel_shape_[1] * kernel_shape_[2] * kernel_shape_[3];\n return {num_rows, num_columns};\n}\n\nstd::pair Conv2DOp::compute_output_matrix_shape() const noexcept {\n assert(verify());\n std::size_t num_rows = kernel_shape_[0];\n std::size_t num_columns = output_shape_[1] * output_shape_[2];\n return {num_rows, num_columns};\n}\n\nTensorDimensions Conv2DOp::get_input_tensor_dims() const noexcept {\n assert(verify());\n return {.batch_size_ = 1,\n .num_channels_ = input_shape_[0],\n .height_ = input_shape_[1],\n .width_ = input_shape_[2]};\n}\n\nTensorDimensions Conv2DOp::get_kernel_tensor_dims() const noexcept {\n assert(verify());\n return {.batch_size_ = kernel_shape_[0],\n .num_channels_ = kernel_shape_[1],\n .height_ = kernel_shape_[2],\n .width_ = kernel_shape_[3]};\n}\n\nTensorDimensions Conv2DOp::get_output_tensor_dims() const noexcept {\n assert(verify());\n return {.batch_size_ = 1,\n .num_channels_ = output_shape_[0],\n .height_ = output_shape_[1],\n .width_ = output_shape_[2]};\n}\n\nbool Conv2DOp::operator==(const Conv2DOp& other) const noexcept {\n assert(verify());\n assert(other.verify());\n bool result = true;\n result = result && kernel_shape_ == other.kernel_shape_;\n result = result && input_shape_ == other.input_shape_;\n result = result && output_shape_ == other.output_shape_;\n result = result && dilations_ == other.dilations_;\n result = result && pads_ == other.pads_;\n result = result && strides_ == other.strides_;\n return result;\n}\n\nbool GemmOp::verify() const noexcept {\n bool result = true;\n std::size_t m = input_A_shape_[0];\n std::size_t k = input_A_shape_[1];\n if (transA_) {\n std::swap(m, k);\n }\n std::size_t n = input_B_shape_[transB_ ? 0 : 1];\n result = result && (k == input_B_shape_[transB_ ? 1 : 0]);\n result = result && (m == output_shape_[0]);\n result = result && (n == output_shape_[1]);\n // maybe add more checks here\n return result;\n}\n\nstd::array GemmOp::compute_output_shape() const noexcept {\n return {input_A_shape_[transA_ ? 1 : 0], input_B_shape_[transB_ ? 0 : 1]};\n}\n\nstd::size_t GemmOp::compute_output_size() const noexcept {\n assert(verify());\n auto output_shape = compute_output_shape();\n return output_shape[0] * output_shape[1];\n}\n\nstd::size_t GemmOp::compute_input_A_size() const noexcept {\n assert(verify());\n return input_A_shape_[0] * input_A_shape_[1];\n}\n\nstd::size_t GemmOp::compute_input_B_size() const noexcept {\n assert(verify());\n return input_B_shape_[0] * input_B_shape_[1];\n}\n\nTensorDimensions GemmOp::get_input_A_tensor_dims() const noexcept {\n assert(verify());\n return {.batch_size_ = 1,\n .num_channels_ = 1,\n .height_ = input_A_shape_[0],\n .width_ = input_A_shape_[1]};\n}\n\nTensorDimensions GemmOp::get_input_B_tensor_dims() const noexcept {\n assert(verify());\n return {.batch_size_ = 1,\n .num_channels_ = 1,\n .height_ = input_B_shape_[0],\n .width_ = input_B_shape_[1]};\n}\n\nTensorDimensions GemmOp::get_output_tensor_dims() const noexcept {\n assert(verify());\n return {.batch_size_ = 1,\n .num_channels_ = 1,\n .height_ = output_shape_[0],\n .width_ = output_shape_[1]};\n}\n\nbool GemmOp::operator==(const GemmOp& other) const noexcept {\n assert(verify());\n assert(other.verify());\n bool result = true;\n result = result && input_A_shape_ == other.input_A_shape_;\n result = result && input_B_shape_ == other.input_B_shape_;\n result = result && output_shape_ == other.output_shape_;\n return result;\n}\n\nTensorDimensions flatten(const TensorDimensions& dims, std::size_t axis) {\n std::size_t height = 1;\n std::size_t width = 1;\n switch (axis) {\n case 0:\n width *= dims.batch_size_;\n [[fallthrough]];\n case 1:\n width *= dims.num_channels_;\n [[fallthrough]];\n case 2:\n width *= dims.height_;\n [[fallthrough]];\n case 3:\n width *= dims.width_;\n }\n switch (axis) {\n case 4:\n height *= dims.width_;\n [[fallthrough]];\n case 3:\n height *= dims.height_;\n [[fallthrough]];\n case 2:\n height *= dims.num_channels_;\n [[fallthrough]];\n case 1:\n height *= dims.batch_size_;\n }\n return {.batch_size_ = 1, .num_channels_ = 1, .height_ = height, .width_ = width};\n}\n\nbool MaxPoolOp::verify() const noexcept {\n bool result = true;\n result = result && (output_shape_ == compute_output_shape());\n result = result && strides_[0] > 0 && strides_[1] > 0;\n result = kernel_shape_[0] <= input_shape_[1] && kernel_shape_[1] <= input_shape_[2];\n // maybe add more checks here\n return result;\n}\n\nstd::array MaxPoolOp::compute_output_shape() const noexcept {\n const auto compute_output_dimension = [](auto input_size, auto kernel_size, auto stride) {\n assert(stride != 0);\n return (input_size - kernel_size + stride) / stride;\n };\n\n std::array output_shape;\n output_shape[0] = input_shape_[0];\n output_shape[1] =\n compute_output_dimension(input_shape_[1], kernel_shape_[2], strides_[0]);\n output_shape[2] =\n compute_output_dimension(input_shape_[2], kernel_shape_[3], strides_[1]);\n return output_shape;\n}\n\nstd::size_t MaxPoolOp::compute_kernel_size() const noexcept {\n assert(verify());\n return kernel_shape_[0] * kernel_shape_[1];\n}\n\nstd::size_t MaxPoolOp::compute_input_size() const noexcept {\n assert(verify());\n return input_shape_[0] * input_shape_[1] * input_shape_[2];\n}\n\nstd::size_t MaxPoolOp::compute_output_size() const noexcept {\n assert(verify());\n return output_shape_[0] * output_shape_[1] * output_shape_[2];\n}\n\nTensorDimensions MaxPoolOp::get_input_tensor_dims() const noexcept {\n assert(verify());\n return {.batch_size_ = 1,\n .num_channels_ = input_shape_[0],\n .height_ = input_shape_[1],\n .width_ = input_shape_[2]};\n}\n\nTensorDimensions MaxPoolOp::get_output_tensor_dims() const noexcept {\n assert(verify());\n return {.batch_size_ = 1,\n .num_channels_ = output_shape_[0],\n .height_ = output_shape_[1],\n .width_ = output_shape_[2]};\n}\n\n} // namespace MOTION::tensor\n\nnamespace std {\n\nstd::size_t std::hash::operator()(\n const MOTION::tensor::Conv2DOp& op) const noexcept {\n std::size_t seed = 0;\n boost::hash_combine(seed,\n boost::hash_range(std::begin(op.kernel_shape_), std::end(op.kernel_shape_)));\n boost::hash_combine(seed,\n boost::hash_range(std::begin(op.input_shape_), std::end(op.input_shape_)));\n boost::hash_combine(seed, boost::hash_range(std::begin(op.dilations_), std::end(op.dilations_)));\n boost::hash_combine(seed, boost::hash_range(std::begin(op.pads_), std::end(op.pads_)));\n boost::hash_combine(seed, boost::hash_range(std::begin(op.strides_), std::end(op.strides_)));\n return seed;\n}\n\nstd::size_t std::hash::operator()(\n const MOTION::tensor::GemmOp& op) const noexcept {\n std::size_t seed = 0;\n boost::hash_combine(\n seed, boost::hash_range(std::begin(op.input_A_shape_), std::end(op.input_A_shape_)));\n boost::hash_combine(\n seed, boost::hash_range(std::begin(op.input_B_shape_), std::end(op.input_B_shape_)));\n return seed;\n}\n\n} // namespace std\n", "meta": {"hexsha": "114dc794caef2757764992ef7f2f153ebf2173e7", "size": 10587, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/motioncore/tensor/tensor_op.cpp", "max_stars_repo_name": "Udbhavbisarya23/MOTION2NX", "max_stars_repo_head_hexsha": "eb26f639d8c1729cebfa85dd3bf41b770cebe92b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2021-11-05T00:39:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-26T16:42:55.000Z", "max_issues_repo_path": "src/motioncore/tensor/tensor_op.cpp", "max_issues_repo_name": "Udbhavbisarya23/MOTION2NX", "max_issues_repo_head_hexsha": "eb26f639d8c1729cebfa85dd3bf41b770cebe92b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7.0, "max_issues_repo_issues_event_min_datetime": "2021-11-07T06:53:00.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-23T11:46:40.000Z", "max_forks_repo_path": "src/motioncore/tensor/tensor_op.cpp", "max_forks_repo_name": "Udbhavbisarya23/MOTION2NX", "max_forks_repo_head_hexsha": "eb26f639d8c1729cebfa85dd3bf41b770cebe92b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2021-11-04T12:01:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T12:15:23.000Z", "avg_line_length": 33.3974763407, "max_line_length": 99, "alphanum_fraction": 0.6865967696, "num_tokens": 2787, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434873426302, "lm_q2_score": 0.6442250996557036, "lm_q1q2_score": 0.4972409475519118}} {"text": "/*\n * ex5.cpp\n *\n * \t\\brief 5. und 7. Aufgabe\n * \\details Liesst eine .gph Datei ein und berechnet den laengsten kuerzesten pfad von jeder Ecke zum Root des Graphen.\n * \\author Christopher Wyczisk\n * \\date 20.07.2017\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \"dijkstra.h\"\n\n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace boost::timer;\n\n// helper\nvector> kanten;\nvector gewichte;\nunsigned int anzahlEckenGlobal;\n\n/**\n *\\typedef Adjancen des Graphen\n */\ntypedef boost::adjacency_list> graph;\n\n/**\n * \\typedef Die Informationen ueber die Ecken des Graphen\n */\ntypedef boost::graph_traits ::vertex_descriptor eckenDto;\n\n/**\n * Einlesen der Graph Datei und Fehlerbehandlung.\n * \n * \\param argc\n * \\param argv\n * \\param infile input Graph-File\n */\nbool graphEinlesen(int argc, char** argv, ifstream& file) {\n\tif(argc <= 1) {\n\t\tcout << \"Sie haben keinen Pfad zu einer .gph Datei angegeben.\" << endl;\n\t\treturn false;\n\t} else {\n\t\tfile.open(argv[1], ios::in);\n\t}\n\n\tif (!file) {\n\t\tcout << \"Die von Ihnen angegebene Datei konnte nicht geoeffnet werden.\" << endl;\n\t\treturn false;\n\t}\n\t\n\treturn true;\n}\n\n/**\n * Konsolen-Ausgabe der Anzahl an Ecken und des Gewichts.\n * \n * \\param anzahlEcken\n * \\param laegsterKuerzesterPfadGewicht\n */\nvoid ergebnisAusgabe(int anzahlEcken, int laegsterKuerzesterPfadGewicht) {\n\tcout << \"RESULT VERTEX \" << anzahlEcken << endl;\n\tcout << \"RESULT DIST \" << laegsterKuerzesterPfadGewicht << endl;\n}\n\n/**\n * Erstellt den Graphen.\n * \n * \\param file\n */\nbool graphErstellen(ifstream& file) {\n\tstringstream str;\n\tstring zeile;\n\tint anzahlKanten;\n\tint start;\n\tint end;\n\tint gewicht;\n\n\tif (getline(file, zeile)) {\n\t\tstr.str(zeile);\n\t\tstr >> anzahlEckenGlobal >> anzahlKanten;\n\t\tanzahlEckenGlobal++;\n\t} else {\n\t\tcerr << \"Das .gph File ist leer.\" << endl;\n\t\treturn false;\n\t}\n\n\twhile (getline(file, zeile)) {\n\t\tstr.clear();\n\t\tstr.str(zeile);\n\t\tstr >> start >> end >> gewicht;\n\t\tkanten.push_back(make_pair(start, end));\n\t\tgewichte.push_back(gewicht);\n\t}\n\t\n\treturn true;\n}\n\n/**\n * Berechnet das Gewicht des longest-shortest Pfad.\n * \n * \\param graph der graph\n * \\param anzahlEcken\n * \\param laengsterKuerzesterPfadGewicht\n */\nvoid berechneLongesteShortesWeigth(graph graph, int& anzahlEcken, int& laegsterKuerzesterPfadGewicht) {\n\tvector pfadRichtungen(anzahlEckenGlobal);\n\tvector gewichteList(anzahlEckenGlobal);\n\n\tboost::dijkstra_shortest_paths(\n\t\tgraph, 1,\n\t\tboost::predecessor_map(\tboost::make_iterator_property_map(pfadRichtungen.begin(), get(boost::vertex_index, graph)))\n\t\t\t.distance_map(\n\t\t\t\t\tboost::make_iterator_property_map(gewichteList.begin(), get(boost::vertex_index, graph\n\t\t\t\t\t))));\n\n\t// berechnet das Gewicht\n\tfor(int i = 1; i < anzahlEckenGlobal; i++) {\n\t\tif (gewichteList[i + 1] > laegsterKuerzesterPfadGewicht) {\n\t\t\tlaegsterKuerzesterPfadGewicht = gewichteList[i + 1];\n\t\t\tanzahlEcken = i + 1;\n\t\t}\n\t}\n}\n\nstring konsolenabfrageWelcheMethode() {\n\tstring eingabe = \"\";\n\twhile(eingabe.compare(\"a\") && eingabe.compare(\"b\")) {\n\t\tcout << \"Geben Sie ein, welcher Algorithmus verwendet werden soll (a=Boots, b=eigene Impelementierung):\" << endl;\n\t\tcin >> eingabe;\n\t}\n\treturn eingabe;\n}\n\n/**\n * Main.\n */\nint main(int argc, char* argv[]) {\n\tifstream file;\n\tbool fileEingelesen = graphEinlesen(argc, argv, file);\n\t\n\tstring eingabe = konsolenabfrageWelcheMethode();\n\t\n\tboost::timer::cpu_timer t;\n\tif(fileEingelesen) {\n\t\t//erstelle den Graph\n\t\tbool erstellt = graphErstellen(file);\n\t\tif(erstellt && !eingabe.compare(\"a\")) {\n\t\t\tgraph graph{kanten.begin(), kanten.end(), gewichte.begin(), anzahlEckenGlobal};\n\t\t\n\t\t\t// berechnen des gewichts des longesten shortesten pfad\n\t\t\tint laegsterKuerzesterPfadGewicht = -1;\n\t\t\tint anzahlEcken = -1;\n\t\t\tberechneLongesteShortesWeigth(graph, anzahlEcken, laegsterKuerzesterPfadGewicht);\n\t\t\t\n\t\t\tergebnisAusgabe(anzahlEcken, laegsterKuerzesterPfadGewicht);\n\t\t}\n\t\telse if(erstellt) {\n\t\t\tvector mapGewichte(anzahlEckenGlobal);\n\t \tdijkstra dijkstra(gewichte, kanten, anzahlEckenGlobal);\n\t\t\tmapGewichte = dijkstra.berechneKuerzestenPfad(1);\n\t\t\t\n\t\t\t// berechnen des gewichts des longesten shortesten pfad\n\t\t\tint laegsterKuerzesterPfadGewicht = -1;\n\t\t\tint anzahlEcken = -1;\n\t\t\tint absGewichte;\n\t\t\tfor(unsigned int i = 2; i < anzahlEckenGlobal; i++) {\n\t\t\t\tabsGewichte = mapGewichte[i];\n\t\t\t\tif (absGewichte > laegsterKuerzesterPfadGewicht) {\n\t\t\t\t\tlaegsterKuerzesterPfadGewicht = absGewichte;\n\t\t\t\t\tanzahlEcken = i;\n\t\t\t\t}\n\t\t\t}\n\t\t\n\t\t\tergebnisAusgabe(anzahlEcken, laegsterKuerzesterPfadGewicht);\n\t\t}\n\t}\n\t\n\tboost::timer::cpu_times zeit = t.elapsed();\n\tstd::cout << \"WALL-CLOCK \" << zeit.wall / 1e9 << \"s\" << std::endl;\n\tstd::cout << \"USER TIME \" << zeit.user / 1e9 << \"s\" << std::endl;\n\treturn 0;\n}\n\n\n\n\n", "meta": {"hexsha": "661f59a792e8ce8b96e5d462a7114effc4acc9ae", "size": 5045, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "christopher_wyczisk/ex5/ex5.cpp", "max_stars_repo_name": "appfs/appfs", "max_stars_repo_head_hexsha": "8cbbfa0e40e4d4a75a498ce8dd894bb2fbc3a9e3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2017-04-21T11:39:55.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-11T20:25:18.000Z", "max_issues_repo_path": "christopher_wyczisk/ex5/ex5.cpp", "max_issues_repo_name": "appfs/appfs", "max_issues_repo_head_hexsha": "8cbbfa0e40e4d4a75a498ce8dd894bb2fbc3a9e3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 69.0, "max_issues_repo_issues_event_min_datetime": "2017-04-26T09:30:38.000Z", "max_issues_repo_issues_event_max_datetime": "2017-08-01T11:31:21.000Z", "max_forks_repo_path": "christopher_wyczisk/ex5/ex5.cpp", "max_forks_repo_name": "appfs/appfs", "max_forks_repo_head_hexsha": "8cbbfa0e40e4d4a75a498ce8dd894bb2fbc3a9e3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 53.0, "max_forks_repo_forks_event_min_datetime": "2017-04-20T16:16:11.000Z", "max_forks_repo_forks_event_max_datetime": "2017-07-19T12:53:01.000Z", "avg_line_length": 25.4797979798, "max_line_length": 122, "alphanum_fraction": 0.703666997, "num_tokens": 1596, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7248702761768249, "lm_q2_score": 0.685949467848392, "lm_q1q2_score": 0.4972243802026099}} {"text": "/*\n * TriangleElement.hpp\n *\n * Created on: Nov 18, 2012\n * Author: petr\n */\n#pragma once\n#ifndef TRIANGLEELEMENT_HPP_\n#define TRIANGLEELEMENT_HPP_\n\n#undef max\n#undef min\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"BoundingBox.hpp\"\n#include \"utility.h\"\n#include \"tribox3.hpp\"\n\n// #include \n// #include \n\n\ntemplate\nstruct SignedDistance {\n\ttype dist;\n\ttype angle;\n\tint sign;\n\tEigen::Vector3d minPoint;\n};\n\n\ntemplate \nclass TriangleElement {\n\n\npublic:\n\n\t/// Stores vertices of an element. \n\t/// This implementation uses triangle element, but in future, there will be support for multiple element types.\n\tstd::vector > vertices;\n\t\n\t/// Face normal\n\tEigen::Vector3d normal;\n\n\t\n\n\t/// element ID used to identify element\n\tlong int ID;\n\n\tTriangleElement(): ID(-1) {};\n\n\t/// Triangle element contructor, triangle normal is computed automaticaly\n\t/// Normal is computed standard way : n = (v1 - v0) x (v2 - v0), where x is cross product\n\tTriangleElement(Eigen::Vector3d& v0, Eigen::Vector3d& v1, Eigen::Vector3d& v2, long int id);\n\n\tTriangleElement(const Eigen::Vector3d& v) {\n\t\tthis->vertices.reserve(3);\n\n\t\tthis->vertices.push_back(v);\n\t\tthis->vertices.push_back(v);\n\t\tthis->vertices.push_back(v);\n\n\t\tthis->ID = -1;\n\t}\n\n\t/// Constructor to create the triangle element from complete list of vertices with an ID\n\tTriangleElement(std::vector >& vertices, long int id);\n\n\tTriangleElement(const TriangleElement & element) : vertices(element.vertices), normal(element.normal), ID(element.ID) {};\n\n\t/// Test whether element is inside the rectangular! region\n\tbool isInsideRegion(const Box& bb) const;\n\n\t/// Test whether element is partly inside the rectangular! region\n\tbool isPartlyInRegion(const Box& bb) const;\n\n\t/// Return centroid of element\n\tEigen::Vector3d centroid();\n\n\tstatic SignedDistance computeDistance(const TriangleElement& el, const Eigen::Vector3d& point);\n\n\tstatic type computePerpendicularDistance(const TriangleElement& el, const Eigen::Vector3d& point);\n\n\t/// Return tight Axis Aligned Bounding Box around element\n\tBoundingBox > getBoundingBox() const;\n\n};\n\ntemplate \nTriangleElement::TriangleElement(Eigen::Vector3d& v0, Eigen::Vector3d& v1, Eigen::Vector3d& v2, long int id) {\n\n\tthis->vertices.reserve(3);\n\n\tthis->vertices.push_back(v0);\n\tthis->vertices.push_back(v1);\n\tthis->vertices.push_back(v2);\n\n\tEigen::Vector3d e0 = v1 - v0;\n\tEigen::Vector3d e1 = v2 - v0;\n\n\tthis->normal = e0.cross(e1);\n\tthis->normal.normalize();\n\n\tthis->ID = id;\n\n}\n\ntemplate \nTriangleElement::TriangleElement(std::vector >& vertices, long int id) {\n\n\tthis->vertices = vertices;\n\n\tEigen::Vector3d e0 = vertices[1] - vertices[0];\n\tEigen::Vector3d e1 = vertices[2] - vertices[0];\n\n\tthis->normal = e0.cross(e1);\n\tthis->normal.normalize();\n\n\tthis->ID = id;\n\n}\n\ntemplate \ninline BoundingBox > TriangleElement::getBoundingBox() const {\n\n\tdouble minX[3], maxX[3];\n\tminX[0] = std::numeric_limits::max();\n\tminX[1] = std::numeric_limits::max();\n\tminX[2] = std::numeric_limits::max();\n\n\tmaxX[0] = -std::numeric_limits::max();\n\tmaxX[1] = -std::numeric_limits::max();\n\tmaxX[2] = -std::numeric_limits::max();\n\n\n\tfor (auto vertex: vertices) {\n\n\t\t// find lower bound\n\t\tif ( vertex[0] < minX[0] ) // for x\n\t\t\tminX[0] = vertex[0];\n\t\tif ( vertex[1] < minX[1] ) // for y\n\t\t\tminX[1] = vertex[1];\n\t\tif ( vertex[2] < minX[2] ) // for z\n\t\t\tminX[2] = vertex[2];\n\n\t\t// find upper bound\n\t\tif ( vertex[0] > maxX[0] ) // for x\n\t\t\tmaxX[0] = vertex[0];\n\t\tif ( vertex[1] > maxX[1] ) // for y\n\t\t\tmaxX[1] = vertex[1];\n\t\tif ( vertex[2] > maxX[2] ) // for z\n\t\t\tmaxX[2] = vertex[2];\n\n\t}\n\n\treturn BoundingBox >(minX, maxX, this);\n\n}\n\ntemplate \ninline bool TriangleElement::isInsideRegion(const Box& bb) const {\n\n\tbool vertex_0 = bb.pointInside(vertices[0].array());\n\tbool vertex_1 = bb.pointInside(vertices[1].array());\n\tbool vertex_2 = bb.pointInside(vertices[2].array());\n\t\n\treturn vertex_0 && vertex_1 && vertex_2;\n\n}\n\n\n\n/// \\brief Detects if triangle element collide with cuboid region. Tests for partial collisions\n/// which could pose a tricky problem: long thin triangles, one vertex collision,\n/// one edge collision, edge to edge collision.\n///\n/// The algorithm is taken from book: (Morgan Kaufmann series in Interactive 3d technology)\n/// Realtime collision detection - Christer Ericson\n///\ntemplate\ninline bool TriangleElement::isPartlyInRegion(const Box& bb) const {\n\n\tfloat trivert[3][3] = { {(float)vertices[0][0], (float)vertices[0][1], (float)vertices[0][2]},\n\t\t\t\t\t\t\t{(float)vertices[1][0], (float)vertices[1][1], (float)vertices[1][2]},\n\t\t\t\t\t\t\t{(float)vertices[2][0], (float)vertices[2][1], (float)vertices[2][2]}};\n\n\tfloat center[3] = {(float)bb.center(0), (float)bb.center(1), (float)bb.center(2)};\n\n\tfloat extent[3] = {(float)bb.extent(0), (float)bb.extent(1), (float)bb.extent(2)};\n\n\t// utilizes code I found on the internet, check the functionality\n\treturn triBoxOverlap(center, extent, trivert);\n\n}\n\ntemplate \ninline SignedDistance TriangleElement::computeDistance(const TriangleElement& el, const Eigen::Vector3d &point) {\n\t// point is supposed to have right dimension, so do it nice and clear :)\n\t// this function computed the distance between triangle element and point in 3D\n\t// complete description of a method could be found here :\n\t// \thttp://www.geometrictools.com/Documentation/DistancePoint3Triangle3.pdf\n\t// sample implementation could be found here :\n\t//\t\thttp://www.geometrictools.com/LibMathematics/Distance/Wm5DistPoint3Triangle3.cpp\n\t// and here :\n\t// \t\thttp://www.mathworks.com/matlabcentral/fileexchange/22857-distance-between-a-point-and-a-triangle-in-3d/\n\n\t//double E0[3] = {el.vertex_x[1] - el.vertex_x[0], el.vertex_y[1] - el.vertex_y[0], el.vertex_z[1] - el.vertex_z[0]};\n\t//double E1[3] = {el.vertex_x[2] - el.vertex_x[0], el.vertex_y[2] - el.vertex_y[0], el.vertex_z[2] - el.vertex_z[0]};\n\n\tEigen::Vector3d E0 = el.vertices[1] - el.vertices[0];\n\tEigen::Vector3d E1 = el.vertices[2] - el.vertices[0];\n\n\t//double D[3] = {el.vertex_x[0] - point[0], el.vertex_y[0] - point[1], el.vertex_z[0] - point[2]};\n\n\tEigen::Vector3d D = el.vertices[0] - point;\n\n//\tdouble a00_ = E0[0]*E0[0] + E0[1]*E0[1] + E0[2]*E0[2];\n\ttype a00 = E0.dot(E0);\n\t\n//\tstd::cout << (a00_ - a00) << std::endl;\n\n//\tdouble a01_ = E0[0]*E1[0] + E0[1]*E1[1] + E0[2]*E1[2];\n\ttype a01 = E0.dot(E1);\n\n//\tstd::cout << (a01_ - a01) << std::endl;\n\n//\tdouble a11_ = E1[0]*E1[0] + E1[1]*E1[1] + E1[2]*E1[2];\n\ttype a11 = E1.dot(E1);\n\t\n//\tstd::cout << (a11_ - a11) << std::endl;\n\n//\tdouble b0_ = E0[0]*D[0] + E0[1]*D[1] + E0[2]*D[2];\n\ttype b0 = E0.dot(D);\n\n//\tstd::cout << (b0_ - b0) << std::endl;\n\n//\tdouble b1_ = E1[0]*D[0] + E1[1]*D[1] + E1[2]*D[2];\n\ttype b1 = E1.dot(D);\n\n//\tstd::cout << (b0_ - b0) << std::endl;\n\n//\tdouble c_ = D[0]*D[0] + D[1]*D[1] + D[2]*D[2];\n\ttype c = D.dot(D);\n\n//\tstd::cout << (c_ - c) << std::endl;\n\n\ttype det = std::abs(a00*a11 - a01*a01);\n\n\ttype s = a01*b1 - a11*b0;\n\ttype t = a01*b0 - a00*b1;\n\n\ttype sqrDistance = 0;\n\n\n\tif ( (s+t) <= det ) {\n\t\tif ( s < 0 ) {\n\t\t\tif ( t < 0 ) {\n\t\t\t\t// region 4\n\t\t\t\tif ( b0 < 0 ) {\n\t\t\t\t\tt = 0;\n\t\t\t\t\tif ( -b0 >= a00 ) {\n\t\t\t\t\t\ts = 1;\n\t\t\t\t\t\tsqrDistance = a00 + 2*b0 + c;\n\t\t\t\t\t} else {\n\t\t\t\t\t\ts = -b0/a00;\n\t\t\t\t\t\tsqrDistance = b0*s + c;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\ts = 0;\n\t\t\t\t\tif ( b1 >= 0 ) {\n\t\t\t\t\t\tt = 0;\n\t\t\t\t\t\tsqrDistance = c;\n\t\t\t\t\t} else if ( -b1 >= a11 ) {\n\t\t\t\t\t\tt = 1;\n\t\t\t\t\t\tsqrDistance = a11 + 2*b1 + c;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tt = -b1/a11;\n\t\t\t\t\t\tsqrDistance = b1*t + c;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// end of region 4\n\t\t\t} else {\n\t\t\t\t// region 3\n\t\t\t\ts = 0;\n\t\t\t\tif ( b1 >= 0 ) {\n\t\t\t\t\tt = 0;\n\t\t\t\t\tsqrDistance = c;\n\t\t\t\t} else if ( -b1 >= a11 ) {\n\t\t\t\t\tt = 1;\n\t\t\t\t\tsqrDistance = a11 + 2*b1 + c;\n\t\t\t\t} else {\n\t\t\t\t\tt = -b1/a11;\n\t\t\t\t\tsqrDistance = b1*t + c;\n\t\t\t\t}\n\t\t\t\t// end of region 3\n\t\t\t}\n\t\t} else if ( t < 0) {\n\t\t\t// region 5\n\t\t\tt = 0;\n\t\t\tif ( b0 >= 0 ) {\n\t\t\t\ts = 0;\n\t\t\t\tsqrDistance = c;\n\t\t\t} else if ( -b0 >= a00 ) {\n\t\t\t\ts = 1;\n\t\t\t\tsqrDistance = a00 + 2*b0 + c;\n\t\t\t} else {\n\t\t\t\ts = -b0/a00;\n\t\t\t\tsqrDistance = b0*s + c;\n\t\t\t}\n\t\t\t// end of region 5\n\t\t} else {\n\t\t\t// region 0\n\t\t\tdouble invDet = 1 / det;\n\t\t\ts *= invDet;\n\t\t\tt *= invDet;\n\t\t\tsqrDistance = s*(a00*s + a01*t + 2*b0) + t*(a01*s + a11*t + 2*b1) + c;\n\t\t\t// end of region 0\n\t\t}\n\t} else {\n\t\tif ( s < 0 ) {\n\t\t\t// region 2\n\t\t\tdouble tmp0 = a01 + b0;\n\t\t\tdouble tmp1 = a11 + b1;\n\t\t\tif ( tmp1 > tmp0 ) { // minimum on edge s+t=1\n\t\t\t\tdouble numer = tmp1 - tmp0;\n\t\t\t\tdouble denom = a00 - 2*a01 + a11;\n\t\t\t\tif ( numer >= denom ) {\n\t\t\t\t\ts = 1;\n\t\t\t\t\tt = 0;\n\t\t\t\t\tsqrDistance = a00 + 2*b0 + c;\n\t\t\t\t} else {\n\t\t\t\t\ts = numer/denom;\n\t\t\t\t\tt = 1 - s;\n\t\t\t\t\tsqrDistance = s*(a00*s + a01*t + 2*b0) + t*(a01*s + a11*t + 2*b1) + c;\n\t\t\t\t}\n\t\t\t} else { // minimum on edge s=0\n\t\t\t\ts = 0;\n\t\t\t\tif ( tmp1 <= 0 ) {\n\t\t\t\t\tt = 1;\n\t\t\t\t\tsqrDistance = a11 + 2*b1 + c;\n\t\t\t\t} else if ( b1 >= 0 ) {\n\t\t\t\t\tt = 0;\n\t\t\t\t\tsqrDistance = c;\n\t\t\t\t} else {\n\t\t\t\t\tt = -b1/a11;\n\t\t\t\t\tsqrDistance = b1*t + c;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// end of region 2\n\t\t} else if ( t < 0 ) {\n\t\t\t// region 6\n\t\t\tdouble tmp0 = a01 + b1;\n\t\t\tdouble tmp1 = a00 + b0;\n\t\t\tif ( tmp1 > tmp0 ) {\n\t\t\t\tdouble numer = tmp1 - tmp0;\n\t\t\t\tdouble denom = a00 - 2*a01 + a11;\n\t\t\t\tif ( numer >= denom ) {\n\t\t\t\t\tt = 1;\n\t\t\t\t\ts = 0;\n\t\t\t\t\tsqrDistance = a11 + 2*b1 + c;\n\t\t\t\t} else {\n\t\t\t\t\tt = numer/denom;\n\t\t\t\t\ts = 1 - t;\n\t\t\t\t\tsqrDistance = s*(a00*s + a01*t + 2*b0) + t*(a01*s + a11*t + 2*b1) + c;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tt = 0;\n\t\t\t\tif ( tmp1 <= 0 ) {\n\t\t\t\t\ts = 1;\n\t\t\t\t\tsqrDistance = a00 + 2*b0 + c;\n\t\t\t\t} else if ( b0 >= 0 ) {\n\t\t\t\t\ts = 0;\n\t\t\t\t\tsqrDistance = c;\n\t\t\t\t} else {\n\t\t\t\t\ts = -b0/a00;\n\t\t\t\t\tsqrDistance = b0*s + c;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// end of region 6\n\t\t} else {\n\t\t\t// region 1\n\t\t\tdouble numer = a11 + b1 - a01 - b0;\n\t\t\tif ( numer <= 0 ) {\n\t\t\t\ts = 0;\n\t\t\t\tt = 1;\n\t\t\t\tsqrDistance = a11 + 2*b1 + c;\n\t\t\t} else {\n\t\t\t\tdouble denom = a00 - 2*a01 + a11;\n\t\t\t\tif ( numer >= denom ) {\n\t\t\t\t\ts = 1;\n\t\t\t\t\tt = 0;\n\t\t\t\t\tsqrDistance = a00 + 2*b0 + c;\n\t\t\t\t} else {\n\t\t\t\t\ts = numer / denom;\n\t\t\t\t\tt = 1 - s;\n\t\t\t\t\tsqrDistance = s*(a00*s + a01*t + 2*b0) + t*(a01*s + a11*t + 2*b1) + c;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// end of region 1\n\t\t}\n\t}\n\n\tdouble eeps = my_eps;\n\n\tif (sqrDistance <= eeps)\n\t\tsqrDistance = 0.0;\n\n\tSignedDistance dist;\n\n\tdist.dist = std::sqrt(sqrDistance);\n\n\tdist.minPoint = el.vertices[0] + s*E0 + t*E1;\n\n//\tdist.minPoint[0] = (el.vertex_x[0] + s*E0[0] + t*E1[0]);\n//\tdist.minPoint[1] = (el.vertex_y[0] + s*E0[1] + t*E1[1]);\n//\tdist.minPoint[2] = (el.vertex_z[0] + s*E0[2] + t*E1[2]);\n\n\n//\tdouble PP0[3] = { point[0] - dist.minPoint[0],\n//\t\t\t\t\t point[1] - dist.minPoint[1],\n//\t\t\t\t\t point[2] - dist.minPoint[2] };\n\n//\tdouble nrm = sqrt(PP0[0]*PP0[0] + PP0[1]*PP0[1] + PP0[2]*PP0[2]);\n\n\t// compute on which side of the triangle we are\n\tEigen::Vector3d PP0 = point - dist.minPoint;\n\t\n\tif ( PP0.isZero(eeps) ) {\n\t\t// PP0 = Eigen::Vector3d::Zero();\n\t} else {\n\t\tPP0.normalize();\n\t}\n\n\n\t//double nrm_normal = sqrt(el.normal_x*el.normal_x + el.normal_y*el.normal_y + el.normal_z*el.normal_z);\n\n//\tdouble dprod = (el.normal_x/nrm_normal) * (PP0[0]/nrm) +\n//\t\t\t\t (el.normal_y/nrm_normal) * (PP0[1]/nrm) +\n//\t\t\t\t (el.normal_z/nrm_normal) * (PP0[2]/nrm);\n\n\n\n\ttype dprod = el.normal.dot(PP0);\n\n//\tstd::cout << el.normal.transpose() << \" DOT \" << PP0.transpose() << \" = \" << dprod << std::endl;\n\n\tint sgn = 0;\n\tif (dprod > eeps)\n\t\tsgn = 1;\n\telse if (dprod < -eeps)\n\t\tsgn = -1;\n\n\tdist.angle = dprod;\n\tdist.sign = sgn;\n\n\treturn dist;\n\n}\n\ntemplate\ninline Eigen::Vector3d TriangleElement::centroid() {\n\n\tEigen::Vector3d c;\n\n\tfor (auto vertex: vertices) {\n\t\tc += vertex;\n\t}\n\n\treturn c*(1.0/3.0);\n\n}\n\ntemplate \ninline type TriangleElement::computePerpendicularDistance(const TriangleElement& el, const Eigen::Vector3d& point) {\n\t// compute projection onto surface defined by the triangle element\n\tEigen::Vector3d vec;\n\tvec << point - el.vertices[0];\n\t\n\ttype ortDist = std::abs( vec.dot(el.normal) );\n\t\n\treturn ortDist;\n}\n\n\n// ostream operators\n\ntemplate \nstd::ostream& operator<<(std::ostream& os, const TriangleElement& el) {\n\tos << \"vert_0: \" << el.vertices[0].transpose() << std::endl;\n\tos << \"vert_1: \" << el.vertices[1].transpose() << std::endl;\n\tos << \"vert_2: \" << el.vertices[2].transpose() << std::endl;\n\tos << \"normal: \" << el.normal.transpose();\n\n return os;\n}\n\n\n\n\n\nstruct TriangleCompare {\n\n\tbool operator() (spatial::dimension_type dim, const TriangleElement& a, const TriangleElement& b) const {\n\n\t\tswitch (dim) {\n\t\t\tcase 0:\n//\t\t\t\ta.vertices[0]\n\t\t\t\treturn (a.vertices[0][0] < b.vertices[0][0]) &&\n\t\t\t\t\t (a.vertices[1][0] < b.vertices[1][0]) &&\n\t\t\t\t\t (a.vertices[2][0] < b.vertices[2][0]);\n\t\t\t\tbreak;\n\t\t\tcase 1:\n\t\t\t\treturn (a.vertices[0][1] < b.vertices[0][1]) &&\n\t\t\t\t\t (a.vertices[1][1] < b.vertices[1][1]) &&\n\t\t\t\t\t (a.vertices[2][1] < b.vertices[2][1]);\n//\t\t\t\treturn (a._tr[0] < b._tr[0]);\n\t\t\t\tbreak;\n\t\t\tcase 2:\n\t\t\t\treturn (a.vertices[0][2] < b.vertices[0][2]) &&\n\t\t\t\t\t (a.vertices[1][2] < b.vertices[1][2]) &&\n\t\t\t\t\t (a.vertices[2][2] < b.vertices[2][2]);\n//\t\t\t\treturn (a._bl[1] < b._bl[1]);\n\t\t\t\tbreak;\n\n\t\t}\n\n\t\treturn false;\n\t}\n\n};\n\nstruct TrianglePredicate {\n\tconst Box& box;\n\n\tTrianglePredicate(const Box& b) : box(b) {}\n\n\tspatial::relative_order\n\toperator() (spatial::dimension_type dim, spatial::dimension_type, const TriangleElement& t ) const {\n\n\t\tBox b = t.getBoundingBox();\n\n\t\tswitch (dim) {\n\t\t\tcase 0:\n\t\t\t\treturn (b._bl[0] > box._tr[0] && b._tr[0] > box._tr[0]) ? spatial::above :\n\t\t\t\t\t (b._tr[0] < box._bl[0] && b._bl[0] < box._bl[0]) ? spatial::below :\n\t\t\t\t\t\tspatial::matching;\n\t\t\t\tbreak;\n\t\t\tcase 1:\n\t\t\t\treturn (b._bl[1] > box._tr[1] && b._tr[1] > box._tr[1]) ? spatial::above :\n\t\t\t\t\t (b._tr[1] < box._bl[1] && b._bl[1] < box._bl[1]) ? spatial::below :\n\t\t\t\t\t\tspatial::matching;\n\t\t\t\tbreak;\n\t\t\tcase 2:\n\t\t\t\treturn (b._bl[2] > box._tr[2] && b._tr[2] > box._tr[2]) ? spatial::above :\n\t\t\t\t\t (b._tr[2] < box._bl[2] && b._bl[2] < box._bl[2]) ? spatial::below :\n\t\t\t\t\t\tspatial::matching;\n\t\t\t\tbreak;\n\t\t}\n\n\t}\n};\n\nstruct TriangleMetric {\n // Check that DistanceType is a fundamental floating point type\n typedef double distance_type;\n\n\n /**\n * Compute the distance between the point of \\c origin and the \\c key.\n * \\return The resulting square distance.\n */\n distance_type\n distance_to_key(spatial::dimension_type rank,\n const TriangleElement& origin,\n const TriangleElement& key) const {\n\n \tdistance_type result = distance_type(0.0);\n\n// \tstd::cout << \"===============================================\" << std::endl;\n// \tstd::cout << origin << std::endl;\n// \tstd::cout << \"--------------\" << std::endl;\n// \tstd::cout << key << std::endl;\n// \tstd::cout << \"--------------\" << std::endl;\n\n \tEigen::Array3d co = (origin.vertices[0] + origin.vertices[1] + origin.vertices[2]).array() / 3.0;\n \tEigen::Array3d ck = (key.vertices[0] + key.vertices[1] + key.vertices[2]).array() / 3.0;\n \t\n \t// distance_type tmp = 0.0\n \t\n\t\tfor (int ii = 0; ii < 3; ++ii) {\n\t\t\tdouble d = std::numeric_limits::max();\n\t\t\tfor (spatial::dimension_type i = 0; i < rank; ++i) {\n\t\t\t\tdouble tmp = std::abs( key.vertices[i][ii] - origin.vertices[i][ii] );\n\t\t\t\td = (tmp < d) ? tmp : d;\n\t\t\t}\n\n\t\t\tresult += d * d;\n\t\t}\n \t\n// \tstd::cout << \"dist = \" << result << std::endl;\n// \tstd::cout << \"===============================================\" << std::endl;\n \treturn result;\n\n }\n\n /**\n * The distance between the point of \\c origin and the closest point to\n * the plane orthogonal to the axis of dimension \\c dim and crossing \\c\n * key.\n * \\return The resulting square distance.\n */\n distance_type\n distance_to_plane(spatial::dimension_type,\n \t\t\t spatial::dimension_type dim,\n const TriangleElement& origin,\n const TriangleElement& key) const {\n\n \tdistance_type d = std::numeric_limits::max();\n\t\tfor (spatial::dimension_type i = 0; i < 3; ++i) {\n\t\t\tdouble tmp = std::abs( key.vertices[i][dim] - origin.vertices[i][dim] );\n\t\t\td = (tmp < d) ? tmp : d;\n\t\t}\n\t\t \t\n\t\treturn d * d;\n\n }\n\n\n};\n\n\n\n\n\n\n\n\n\n\n\n#endif /* TRIANGLEELEMENT_HPP_ */\n", "meta": {"hexsha": "5acd08633347ceb2d51a658f11907eed242b7d7a", "size": 16944, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/TriangleElement.hpp", "max_stars_repo_name": "petrkotas/libLS", "max_stars_repo_head_hexsha": "eb57365bfb0be486a4e8c564ff831ad358993268", "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/TriangleElement.hpp", "max_issues_repo_name": "petrkotas/libLS", "max_issues_repo_head_hexsha": "eb57365bfb0be486a4e8c564ff831ad358993268", "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/TriangleElement.hpp", "max_forks_repo_name": "petrkotas/libLS", "max_forks_repo_head_hexsha": "eb57365bfb0be486a4e8c564ff831ad358993268", "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.1481481481, "max_line_length": 137, "alphanum_fraction": 0.5865203022, "num_tokens": 5651, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7431680086124812, "lm_q2_score": 0.6688802603710086, "lm_q1q2_score": 0.49709041110012037}} {"text": "#include \n#include \n#include \n\nnamespace py=pybind11;\ntypedef Eigen::MatrixXd Matrix;\ntypedef Eigen::VectorXd Vector;\n\nEigen::Ref distance_table(\n Eigen::Ref& pos, double lbox)\n{\n const int natom = pos.rows();\n const int ndim = pos.cols();\n Matrix dtable = Matrix::Zero(natom, natom);\n Vector drij(ndim);\n for (int i=0;i\n#include \n#include \n#include \n#include \n\n#include \"opengl_tools.h\"\n#include \"Scene_polyhedron_item.h\"\n#include \"Scene_surface_mesh_item.h\"\n#include \"Scene_points_with_normal_item.h\"\n#include \"Scene_polylines_item.h\"\n#include \"Scene_polyhedron_selection_item.h\"\n#include \"Polyhedron_type.h\"\n\n#include \n\n#include \n#include \n#include \nusing namespace CGAL::Three;\nclass Polyhedron_demo_convex_hull_plugin : \n public QObject,\n public Polyhedron_demo_plugin_interface\n{\n Q_OBJECT\n Q_INTERFACES(CGAL::Three::Polyhedron_demo_plugin_interface)\n Q_PLUGIN_METADATA(IID \"com.geometryfactory.PolyhedronDemo.PluginInterface/1.0\")\npublic:\n void init(QMainWindow*mw,\n Scene_interface* scene_interface,\n Messages_interface*)\n {\n scene = scene_interface;\n this->mw = mw;\n QAction *actionConvexHull = new QAction(\"Convex Hull\", mw);\n actionConvexHull->setProperty(\"subMenuName\",\"3D Convex Hulls\");\n connect(actionConvexHull, SIGNAL(triggered()), this, SLOT(on_actionConvexHull_triggered()));\n _actions < actions()const {return _actions;}\n\n bool applicable(QAction*) const {\n return \n qobject_cast(scene->item(scene->mainSelectionIndex())) ||\n qobject_cast(scene->item(scene->mainSelectionIndex())) ||\n qobject_cast(scene->item(scene->mainSelectionIndex())) ||\n qobject_cast(scene->item(scene->mainSelectionIndex())) ||\n qobject_cast(scene->item(scene->mainSelectionIndex()));\n }\n\npublic Q_SLOTS:\n void on_actionConvexHull_triggered();\nprivate:\n QList _actions;\n Scene_interface* scene;\n QMainWindow* mw;\n}; // end Polyhedron_demo_convex_hull_plugin\n\n// for transform iterator\nstruct Get_point {\n typedef const Polyhedron::Point_3& result_type;\n result_type operator()(const Polyhedron::Vertex_handle v) const\n { return v->point(); }\n};\n\nvoid Polyhedron_demo_convex_hull_plugin::on_actionConvexHull_triggered()\n{\n const CGAL::Three::Scene_interface::Item_id index = scene->mainSelectionIndex();\n \n Scene_polyhedron_item* poly_item = \n qobject_cast(scene->item(index));\n\n Scene_points_with_normal_item* pts_item =\n qobject_cast(scene->item(index));\n \n Scene_polylines_item* lines_item = \n qobject_cast(scene->item(index));\n \n Scene_polyhedron_selection_item* selection_item = \n qobject_cast(scene->item(index));\n\n Scene_surface_mesh_item* sm_item = \n qobject_cast(scene->item(index));\n\n if(poly_item || pts_item || lines_item || selection_item || sm_item)\n {\n // wait cursor\n QApplication::setOverrideCursor(Qt::WaitCursor);\n \n QTime time;\n time.start();\n std::cout << \"Convex hull...\";\n\n // add convex hull as new polyhedron\n SMesh *pConvex_hull = new SMesh;\n if(selection_item) {\n CGAL::convex_hull_3(\n boost::make_transform_iterator(selection_item->selected_vertices.begin(), Get_point()),\n boost::make_transform_iterator(selection_item->selected_vertices.end(), Get_point()),\n *pConvex_hull);\n }\n else if ( poly_item ){\n Polyhedron* pMesh = poly_item->polyhedron(); \n CGAL::convex_hull_3(pMesh->points_begin(),pMesh->points_end(),*pConvex_hull);\n }\n else if ( sm_item ){\n SMesh* pMesh = sm_item->polyhedron();\n typedef boost::property_map::type Vpmap;\n \n typedef CGAL::Property_map_to_unary_function Vpmap_fct;\n Vpmap vpm = get(CGAL::vertex_point,*pMesh);\n \n Vpmap_fct v2p(vpm);\n boost::graph_traits::vertex_iterator b,e;\n boost::tie(b,e) = vertices(*pMesh);\n \n CGAL::convex_hull_3(boost::make_transform_iterator(b,v2p),\n boost::make_transform_iterator(e,v2p),\n *pConvex_hull);\n \n }\n else{\n if (pts_item)\n CGAL::convex_hull_3(pts_item->point_set()->points().begin(),\n pts_item->point_set()->points().end(),\n *pConvex_hull);\n else{\n std::size_t nb_points=0;\n for(std::list >::const_iterator it = lines_item->polylines.begin();\n it != lines_item->polylines.end();\n ++it) nb_points+=it->size();\n\n std::vector all_points;\n all_points.reserve( nb_points );\n\n for(std::list >::const_iterator it = lines_item->polylines.begin();\n it != lines_item->polylines.end();\n ++it) std::copy(it->begin(), it->end(),std::back_inserter( all_points ) );\n \n CGAL::convex_hull_3(all_points.begin(),all_points.end(),*pConvex_hull);\n }\n }\n std::cout << \"ok (\" << time.elapsed() << \" ms)\" << std::endl;\n\n if(mw->property(\"is_polyhedron_mode\").toBool()){\n Polyhedron *poly = new Polyhedron;\n CGAL::copy_face_graph(*pConvex_hull,*poly);\n delete pConvex_hull;\n\n Scene_polyhedron_item* new_item = new Scene_polyhedron_item(poly);\n new_item->setName(tr(\"%1 (convex hull)\").arg(scene->item(index)->name()));\n new_item->setColor(Qt::magenta);\n new_item->setRenderingMode(FlatPlusEdges);\n scene->addItem(new_item);\n } else {\n Scene_surface_mesh_item* new_item = new Scene_surface_mesh_item(pConvex_hull);\n new_item->setName(tr(\"%1 (convex hull)\").arg(scene->item(index)->name()));\n new_item->setColor(Qt::magenta);\n new_item->setRenderingMode(FlatPlusEdges);\n scene->addItem(new_item);\n }\n\n // default cursor\n QApplication::restoreOverrideCursor();\n }\n\n\n}\n\n#include \"Convex_hull_plugin.moc\"\n", "meta": {"hexsha": "5d2e487337e4c1bdb9aa7cf145f2c1b7343181a4", "size": 6118, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ext/libigl/external/cgal/src/CGAL_Project/demo/Polyhedron/Plugins/Convex_hull/Convex_hull_plugin.cpp", "max_stars_repo_name": "liminchen/OptCuts", "max_stars_repo_head_hexsha": "cb85b06ece3a6d1279863e26b5fd17a5abb0834d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 187.0, "max_stars_repo_stars_event_min_datetime": "2019-01-23T04:07:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T03:44:58.000Z", "max_issues_repo_path": "ext/libigl/external/cgal/src/CGAL_Project/demo/Polyhedron/Plugins/Convex_hull/Convex_hull_plugin.cpp", "max_issues_repo_name": "xiaoxie5002/OptCuts", "max_issues_repo_head_hexsha": "1f4168fc867f47face85fcfa3a572be98232786f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8.0, "max_issues_repo_issues_event_min_datetime": "2019-03-22T13:27:38.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-18T13:23:23.000Z", "max_forks_repo_path": "ext/libigl/external/cgal/src/CGAL_Project/demo/Polyhedron/Plugins/Convex_hull/Convex_hull_plugin.cpp", "max_forks_repo_name": "xiaoxie5002/OptCuts", "max_forks_repo_head_hexsha": "1f4168fc867f47face85fcfa3a572be98232786f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 34.0, "max_forks_repo_forks_event_min_datetime": "2019-02-13T01:11:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-28T03:29:40.000Z", "avg_line_length": 35.5697674419, "max_line_length": 104, "alphanum_fraction": 0.6829029094, "num_tokens": 1556, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7431680086124812, "lm_q2_score": 0.668880247169804, "lm_q1q2_score": 0.49709040128940746}} {"text": "#ifndef constraint_hpp\n#define constraint_hpp\n\n#include \n#include \n#include \n\nnamespace elasty\n{\n struct Particle;\n\n enum class ConstraintType { Bilateral, Unilateral };\n\n class Constraint\n {\n public:\n\n Constraint(const std::vector>& particles,\n const double stiffness) :\n m_stiffness(stiffness),\n m_particles(particles)\n {\n }\n\n /// \\brief Calculates the constraint function value C(x).\n virtual double calculateValue() = 0;\n\n /// \\brief Calculate the derivative of the constraint function\n /// grad C(x).\n /// \\details As constraints can have different vector sizes, it will\n /// store the result to the passed raw buffer that should be allocated\n /// in the caller, rather than returning a dynamically allocated\n /// variable-length vector. This method does not check whether the\n /// buffer is adequately allocated, or not.\n virtual void calculateGrad(double* grad_C) = 0;\n\n /// \\brief Manipulate the associated particles by projecting them to the\n /// constraint manifold.\n /// \\details This method should be called by the core engine. As this\n /// method directly updates the predicted positions of the associated\n /// particles, it is intended to be used in a Gauss-Seidel-style solver.\n virtual void projectParticles() = 0;\n\n /// \\brief Return the constraint type (i.e., either unilateral or\n /// bilateral).\n virtual ConstraintType getType() = 0;\n\n /// \\brief Stiffness of this constraint, which should be in [0, 1].\n double m_stiffness;\n\n protected:\n\n /// \\brief Associated particles.\n /// \\details The number of particles is (in most cases) solely\n /// determined in each constraint. For example, a distance constraint\n /// need to have exactly two particles. Some special constraints\n /// (e.g., shape-matching constraint) could have a variable number of\n /// particles.\n std::vector> m_particles;\n };\n\n class BendingConstraint final : public Constraint\n {\n public:\n\n BendingConstraint(const std::shared_ptr p_0,\n const std::shared_ptr p_1,\n const std::shared_ptr p_2,\n const std::shared_ptr p_3,\n const double stiffness,\n const double dihedral_angle);\n\n double calculateValue() override;\n void calculateGrad(double* grad_C) override;\n void projectParticles() override;\n ConstraintType getType() override { return ConstraintType::Bilateral; }\n\n private:\n\n const Eigen::Matrix m_inv_M;\n const double m_dihedral_angle;\n };\n\n class DistanceConstraint final : public Constraint\n {\n public:\n\n DistanceConstraint(const std::shared_ptr p_0,\n const std::shared_ptr p_1,\n const double stiffness,\n const double d);\n \n double calculateValue() override;\n void calculateGrad(double* grad_C) override;\n void projectParticles() override;\n ConstraintType getType() override { return ConstraintType::Bilateral; }\n\n private:\n\n const Eigen::Matrix m_inv_M;\n const double m_d;\n };\n\n class EnvironmentalCollisionConstraint final : public Constraint\n {\n public:\n\n EnvironmentalCollisionConstraint(const std::shared_ptr p_0,\n const double stiffness,\n const Eigen::Vector3d& n,\n const double d);\n\n double calculateValue() override;\n void calculateGrad(double* grad_C) override;\n void projectParticles() override;\n ConstraintType getType() override { return ConstraintType::Unilateral; }\n\n private:\n\n const Eigen::Matrix m_inv_M;\n const Eigen::Vector3d m_n;\n const double m_d;\n };\n\n class FixedPointConstraint final : public Constraint\n {\n public:\n\n FixedPointConstraint(const std::shared_ptr p_0,\n const double stiffness,\n const Eigen::Vector3d& point);\n\n double calculateValue() override;\n void calculateGrad(double* grad_C) override;\n void projectParticles() override;\n ConstraintType getType() override { return ConstraintType::Bilateral; }\n\n private:\n\n const Eigen::Matrix m_inv_M;\n const Eigen::Vector3d m_point;\n };\n\n class IsometricBendingConstraint final : public Constraint\n {\n public:\n\n IsometricBendingConstraint(const std::shared_ptr p_0,\n const std::shared_ptr p_1,\n const std::shared_ptr p_2,\n const std::shared_ptr p_3,\n const double stiffness);\n\n double calculateValue() override;\n void calculateGrad(double* grad_C) override;\n void projectParticles() override;\n ConstraintType getType() override { return ConstraintType::Bilateral; }\n\n private:\n\n const Eigen::Matrix m_inv_M;\n Eigen::Matrix4d m_Q;\n };\n}\n\n#endif /* constraint_hpp */\n", "meta": {"hexsha": "c8f962ca119790b41954e5ed84b227469c1e4213", "size": 5628, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/elasty/constraint.hpp", "max_stars_repo_name": "0x0c/elasty", "max_stars_repo_head_hexsha": "3995cacbefa8d7f39249e9f75fa291828e2e7c2d", "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/elasty/constraint.hpp", "max_issues_repo_name": "0x0c/elasty", "max_issues_repo_head_hexsha": "3995cacbefa8d7f39249e9f75fa291828e2e7c2d", "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/elasty/constraint.hpp", "max_forks_repo_name": "0x0c/elasty", "max_forks_repo_head_hexsha": "3995cacbefa8d7f39249e9f75fa291828e2e7c2d", "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.7005988024, "max_line_length": 80, "alphanum_fraction": 0.605366027, "num_tokens": 1116, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7549149868676283, "lm_q2_score": 0.6584175072643413, "lm_q1q2_score": 0.49704924384987675}} {"text": "\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\ntypedef CGAL::Exact_predicates_inexact_constructions_kernel K;\ntypedef CGAL::Delaunay_triangulation_3 Triangulation;\ntypedef Triangulation::Point Point;\n\n// using a global for this is not good. I really should be passing it\n// some other way.\ndouble scale_z=1.0;\n\n// these two functions are for my readvtk function.\nTriangulation::Vertex_handle\nadd_vertex(Triangulation &T, std::string& vname, double x, double y, double z)\n{\n // the exp(z) scaling shouldn't be done here.\n // max value of z is 1000. in that case, z/1000 =1.\n // which leaves us with exp(log(1000) which == 1000\n double newz = scale_z*exp(log(1000.0)*z/1000.0);;\n return T.insert(Point(x,y,newz));\n}\n\nvoid add_edge(Triangulation &T,\n Triangulation::Vertex_handle s,\n Triangulation::Vertex_handle t)\n{\n // no edges to add. CGAL does that.\n}\n\n#include \n\nstruct VertexData {\n std::string name;\n double x,y,z;\n};\n\nstruct EdgeData {\n double distance;\n};\n\ntypedef boost::adjacency_list\n > MyGraphType;\n\n\n\n// these are needed by readvtk\ntypedef typename boost::graph_traits::vertex_descriptor vertex_descriptor;\ntypedef typename boost::graph_traits::edge_descriptor edge_descriptor;\ntypename boost::graph_traits::vertex_descriptor\nadd_vertex(MyGraphType &G, std::string& vname, double x, double y, double z)\n{\n typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor;\n vertex_descriptor v = add_vertex(G);\n G[v].x = x;\n G[v].y = y;\n G[v].z = z;\n return v;\n}\n\ninline\ndouble distance(MyGraphType &G,\n typename boost::graph_traits::vertex_descriptor v1,\n typename boost::graph_traits::vertex_descriptor v2)\n{\n return sqrt((G[v1].x - G[v2].x)*(G[v1].x - G[v2].x) +\n (G[v1].y - G[v2].y)*(G[v1].y - G[v2].y) +\n (G[v1].z - G[v2].z)*(G[v1].z - G[v2].z));\n}\n\n\ntypename boost::graph_traits::edge_descriptor\nadd_edge(MyGraphType &G,\n typename boost::graph_traits::vertex_descriptor v1,\n typename boost::graph_traits::vertex_descriptor v2)\n{\n typedef typename boost::graph_traits::edge_descriptor edge_descriptor;\n edge_descriptor e = add_edge(v1, v2, G).first;\n boost::property_map::type weightmap = get(boost::edge_weight, G);\n weightmap[e] = distance(G, v1, v2);\n return e;\n}\n\n\n\n#include \n\n\nenum MSTAlgorithm { PRIM, KRUSKAL };\nstd::istream& operator>>(std::istream& in, MSTAlgorithm &format)\n{\n std::string token;\n in >> token;\n if (token == \"prim\")\n format = PRIM;\n else if (token == \"kruskal\")\n format = KRUSKAL;\n else \n in.setstate(std::ios_base::failbit);\n return in;\n}\n\n\nint\nmain(int argc,char* argv[])\n{\n\n namespace po = boost::program_options;\n po::options_description desc(\"Usage\");\n\n std::string filename;\n desc.add_options()\n (\"help\", \"produce help message\")\n (\"filename\", po::value(&filename)->default_value(\"\"),\n \"filename containing input points\");\n\n MSTAlgorithm mst_algorithm;\n desc.add_options()\n (\"algorithm\", po::value(&mst_algorithm)->default_value(KRUSKAL),\n \"which output format\"); \n\n desc.add_options()\n (\"scale\", po::value(&scale_z)->default_value(1.0),\n \"scale factor\");\n \n \n po::variables_map opts;\n po::store(po::parse_command_line(argc, argv, desc), opts);\n\n try {\n po::notify(opts);\n } catch (std::exception& e) {\n std::cerr << \"Error: \" << e.what() << \"\\n\";\n return 1;\n }\n\n if (filename == \"\") {\n std::cerr << \"please provide a vtk file with the --filename option\" << std::endl;\n exit(-1);\n }\n std::ifstream input(filename.c_str());\n\n std::cerr << \"using scale factor \" << scale_z << std::endl;\n \n Triangulation T;\n readvtk(input, T);\n assert( T.is_valid() ); // checking validity of T\n\n // at this point, the points have been loaded and the triangulation is done.\n \n MyGraphType G;\n\n std::map vertex_map;\n\n Triangulation::Finite_vertices_iterator viter;\n for (viter = T.finite_vertices_begin();\n viter != T.finite_vertices_end();\n viter++) {\n Triangulation::Triangulation_data_structure::Vertex v = *viter;\n Point p = v.point();\n double x = CGAL::to_double(p.x());\n double y = CGAL::to_double(p.y());\n double z = CGAL::to_double(p.z());\n std::string d(\"\");\n auto boost_vertex = vertex_map[v.point()] = add_vertex(G, d, x,y,z);\n \n }\n\n Triangulation::Finite_edges_iterator iter;\n for(iter = T.finite_edges_begin();\n iter != T.finite_edges_end();\n iter++) {\n // edges are not represented as edges in CGAL triangulation graphs.\n // Instead, they are stored in faces/cells.\n\n Triangulation::Triangulation_data_structure::Edge e = *iter;\n Triangulation::Triangulation_data_structure::Cell_handle c = e.first;\n int i = e.second;\n int j = e.third;\n auto boost_edge = add_edge(G, vertex_map[c->vertex(i)->point()], vertex_map[c->vertex(j)->point()]);\n }\n\n\n \n \n std::cerr << \"running prim\" << std::endl;\n std::vector mst_prim(num_vertices(G));\n\n std::cout << \"# vtk DataFile Version 1.0\\n\";\n std::cout << \"3D triangulation data\\n\";\n std::cout << \"ASCII\\n\";\n std::cout << std::endl;\n std::cout << \"DATASET POLYDATA\\n\";\n\n std::cout << \"POINTS \" << num_vertices(G) << \" float\\n\";\n for(int i=0; i\n //\n typedef boost::property_map::type IdMap;\n boost::iterator_property_map::iterator,\n IdMap,\n vertex_descriptor,\n vertex_descriptor&>\n predmap(mst_prim.begin(), get(boost::vertex_index, G));\n \n boost::prim_minimum_spanning_tree(G, predmap);\n\n for(int i=0; i::edge_descriptor> mst_kruskal;\n boost::kruskal_minimum_spanning_tree(G, std::back_inserter(mst_kruskal));\n\n for(auto iter=mst_kruskal.begin();\n iter != mst_kruskal.end();\n iter++) {\n std::cout << \"2 \" << source(*iter, G) << \" \" << target(*iter, G) <\n#include \n#include \n#include \n#include \n\nvoid require(bool cond, const char* msg)\n{\n if (!cond) {\n std::cerr << \"ERROR: \" << msg << \"!\" << std::endl;\n exit(1);\n }\n}\n\nenum Op { LEQ, LT, GT, GEQ, EQ, ADD, SUB, MUL, DIV, AND, OR, NOT };\n\nstruct StackItem\n{\n typedef boost::multiprecision::mpq_rational val_t;\n\n enum Kind { OP, VAL, BV } kind;\n Op op;\n val_t val;\n bool bv;\n\n StackItem(Op o) : kind(OP), op(o) {}\n StackItem(val_t v) : kind(VAL), val(v) {}\n StackItem(bool b) : kind(BV), bv(b) {}\n\n friend std::ostream& operator<< (std::ostream& stream, const StackItem& si);\n};\n\nstd::ostream& operator<< (std::ostream& stream, const StackItem& si)\n{\n switch (si.kind) {\n case StackItem::OP:\n stream << \"op: \" << si.op;\n break;\n case StackItem::VAL:\n stream << si.val;\n break;\n case StackItem::BV:\n stream << (si.bv ? \"true\" : \"false\");\n break;\n }\n return stream;\n}\n\n#define CHECK_BIN(type)\\\n require(operands.size() == 2, \"Invalid number of arguments for binary operator\");\\\n require(operands[0].kind == StackItem::type, \"Invalid first argument type\");\\\n require(operands[1].kind == StackItem::type, \"Invalid second argument type\");\n\n#define CHECK_UN(type)\\\n require(operands.size() == 1, \"Invalid number of arguments for unary operator\");\\\n require(operands[0].kind == StackItem::type, \"Invalid argument type\");\n\nStackItem eval(Op o, const std::deque& operands)\n{\n switch (o) {\n case LEQ: CHECK_BIN(VAL);\n return StackItem(operands[0].val <= operands[1].val);\n case GEQ: CHECK_BIN(VAL);\n return StackItem(operands[0].val >= operands[1].val);\n case LT: CHECK_BIN(VAL);\n return StackItem(operands[0].val < operands[1].val);\n case GT: CHECK_BIN(VAL);\n return StackItem(operands[0].val > operands[1].val);\n case EQ: CHECK_BIN(VAL);\n return StackItem(operands[0].val == operands[1].val);\n case ADD: CHECK_BIN(VAL);\n return StackItem(operands[0].val + operands[1].val);\n case SUB:\n if (operands.size() == 1) {\n CHECK_UN(VAL);\n return StackItem(- operands[0].val);\n } else if (operands.size() == 2) {\n CHECK_BIN(VAL);\n return StackItem(operands[0].val - operands[1].val);\n } else {\n require(false, \"Invalid number of arguments for operator '-'\");\n }\n case MUL: CHECK_BIN(VAL);\n return StackItem(operands[0].val * operands[1].val);\n case DIV: CHECK_BIN(VAL);\n require(operands[1].val != 0, \"Division by zero\");\n return StackItem(operands[0].val / operands[1].val);\n case AND: CHECK_BIN(BV);\n return StackItem(operands[0].bv && operands[1].bv);\n case OR: CHECK_BIN(BV);\n return StackItem(operands[0].bv || operands[1].bv);\n case NOT: CHECK_UN(BV);\n return StackItem(!operands[0].bv);\n default:\n require(false, \"Invalid operation!\");\n }\n}\n\n#define EXPECT(x) require(std::getchar() == x, \"Expected \" #x);\n\nint main(int argc, char *argv[])\n{\n std::deque stack;\n char chr = std::getchar();\n while (chr != EOF) {\n switch (chr) {\n case '<':\n chr = std::getchar();\n if (chr == '=') {\n stack.emplace_back(Op::LEQ);\n } else {\n stack.emplace_back(Op::LT);\n continue;\n }\n break;\n case '>':\n chr = std::getchar();\n if (chr == '=') {\n stack.emplace_back(Op::GEQ);\n } else {\n stack.emplace_back(Op::GT);\n continue;\n }\n break;\n case '=':\n stack.emplace_back(Op::EQ);\n break;\n case 'a': EXPECT('n'); EXPECT('d');\n stack.emplace_back(Op::AND);\n break;\n case 'o': EXPECT('r');\n stack.emplace_back(Op::OR);\n break;\n case 'n': EXPECT('o'); EXPECT('t');\n stack.emplace_back(Op::NOT);\n break;\n case '+':\n stack.emplace_back(Op::ADD);\n break;\n case '-':\n stack.emplace_back(Op::SUB);\n break;\n case '*':\n stack.emplace_back(Op::MUL);\n break;\n case '/':\n stack.emplace_back(Op::DIV);\n break;\n case '0': case '1': case '2': case '3': case '4':\n case '5': case '6': case '7': case '8': case '9': {\n std::stringstream sb;\n sb << chr;\n chr = getchar();\n while (chr >= '0' && chr <= '9') {\n sb << chr;\n chr = getchar();\n }\n stack.emplace_back(StackItem::val_t(sb.str()));\n continue;\n }\n break;\n case ')': {\n std::deque v;\n while (stack.back().kind != StackItem::OP) {\n v.push_front(stack.back());\n stack.pop_back();\n }\n auto o = stack.back().op;\n stack.pop_back();\n stack.push_back(eval(o, v));\n }\n break;\n case ' ': case '\\n': case '\\t': case '(':\n break;\n default:\n require(false, \"Invalid input\");\n }\n chr = getchar();\n }\n\n for (const auto& si : stack) {\n std::cout << \"> \" << si << std::endl;\n }\n\n return 0;\n}\n", "meta": {"hexsha": "c7576492fd159beb84237d0fcad60a3c3f34a33f", "size": 6085, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/fLispEval.cpp", "max_stars_repo_name": "fabian-r/fLispEval", "max_stars_repo_head_hexsha": "ca6a7ccaa579a4d1277d1a2790de504ee6a4ff28", "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/fLispEval.cpp", "max_issues_repo_name": "fabian-r/fLispEval", "max_issues_repo_head_hexsha": "ca6a7ccaa579a4d1277d1a2790de504ee6a4ff28", "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/fLispEval.cpp", "max_forks_repo_name": "fabian-r/fLispEval", "max_forks_repo_head_hexsha": "ca6a7ccaa579a4d1277d1a2790de504ee6a4ff28", "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": 32.5401069519, "max_line_length": 94, "alphanum_fraction": 0.4599835661, "num_tokens": 1395, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.808067204308405, "lm_q2_score": 0.6150878555160666, "lm_q1q2_score": 0.49703232381092005}} {"text": "/*----------------------------------------------------------------------------*/\n/* Copyright (c) 2019-2020 FIRST. All Rights Reserved. */\n/* Open Source Software - may be modified and shared by FRC teams. The code */\n/* must be accompanied by the FIRST BSD license file in the root directory of */\n/* the project. */\n/*----------------------------------------------------------------------------*/\n\n#include \n\n#include \n\n#include \n#include \n\n#include \"drake/math/discrete_algebraic_riccati_equation.h\"\n#include \"edu_wpi_first_wpiutil_math_DrakeJNI.h\"\n#include \"wpi/jni_util.h\"\n\nusing namespace wpi::java;\n\nextern \"C\" {\n\n/*\n * Class: edu_wpi_first_wpiutil_math_DrakeJNI\n * Method: discreteAlgebraicRiccatiEquation\n * Signature: ([D[D[D[DII[D)V\n */\nJNIEXPORT void JNICALL\nJava_edu_wpi_first_wpiutil_math_DrakeJNI_discreteAlgebraicRiccatiEquation\n (JNIEnv* env, jclass, jdoubleArray A, jdoubleArray B, jdoubleArray Q,\n jdoubleArray R, jint states, jint inputs, jdoubleArray S)\n{\n jdouble* nativeA = env->GetDoubleArrayElements(A, nullptr);\n jdouble* nativeB = env->GetDoubleArrayElements(B, nullptr);\n jdouble* nativeQ = env->GetDoubleArrayElements(Q, nullptr);\n jdouble* nativeR = env->GetDoubleArrayElements(R, nullptr);\n\n Eigen::Map<\n Eigen::Matrix>\n Amat{nativeA, states, states};\n Eigen::Map<\n Eigen::Matrix>\n Bmat{nativeB, states, inputs};\n Eigen::Map<\n Eigen::Matrix>\n Qmat{nativeQ, states, states};\n Eigen::Map<\n Eigen::Matrix>\n Rmat{nativeR, inputs, inputs};\n\n Eigen::MatrixXd result =\n drake::math::DiscreteAlgebraicRiccatiEquation(Amat, Bmat, Qmat, Rmat);\n\n env->ReleaseDoubleArrayElements(A, nativeA, 0);\n env->ReleaseDoubleArrayElements(B, nativeB, 0);\n env->ReleaseDoubleArrayElements(Q, nativeQ, 0);\n env->ReleaseDoubleArrayElements(R, nativeR, 0);\n\n env->SetDoubleArrayRegion(S, 0, states * states, result.data());\n}\n\n} // extern \"C\"\n", "meta": {"hexsha": "8e5f4da4f98aa8ecef8e4ee1b93321a17ef5df9f", "size": 2297, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "wpiutil/src/main/native/cpp/jni/DrakeJNI.cpp", "max_stars_repo_name": "carbotaniuman/allwpilib", "max_stars_repo_head_hexsha": "5cf4c16f5b2d3ae0ba49d928f4285e400d05497a", "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": "wpiutil/src/main/native/cpp/jni/DrakeJNI.cpp", "max_issues_repo_name": "carbotaniuman/allwpilib", "max_issues_repo_head_hexsha": "5cf4c16f5b2d3ae0ba49d928f4285e400d05497a", "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": "wpiutil/src/main/native/cpp/jni/DrakeJNI.cpp", "max_forks_repo_name": "carbotaniuman/allwpilib", "max_forks_repo_head_hexsha": "5cf4c16f5b2d3ae0ba49d928f4285e400d05497a", "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.4603174603, "max_line_length": 80, "alphanum_fraction": 0.6478014802, "num_tokens": 589, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8080671950640463, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.49703231812482723}} {"text": "<<<<<<< HEAD\n/* Copyright (c) 2010-2018, Delft University of Technology\n=======\n/* Copyright (c) 2010-2019, Delft University of Technology\n>>>>>>> origin/master\n * All rigths reserved\n *\n * This file is part of the Tudat. Redistribution and use in source and\n * binary forms, with or without modification, are permitted exclusively\n * under the terms of the Modified BSD license. You should have received\n * a copy of the license with this file. If not, please or visit:\n * http://tudat.tudelft.nl/LICENSE.\n */\n\n#include \n#include \n\n#include \"Tudat/Mathematics/Statistics/boostProbabilityDistributions.h\"\n\nnamespace tudat\n{\n\nnamespace statistics\n{\n\n//! Function to create a random variable class of BoostContinuousProbabilityDistribution type\nstd::shared_ptr< InvertibleContinuousProbabilityDistribution< double > > createBoostRandomVariable(\n const ContinuousBoostStatisticalDistributions boostDistribution, const std::vector< double >& parameters )\n{\n using namespace boost::math;\n\n std::shared_ptr< InvertibleContinuousProbabilityDistribution< double > > continuousRandomVariable;\n\n // Check which distribution type is requested\n switch( boostDistribution )\n {\n case uniform_boost_distribution:\n {\n // Check number of provided parameters\n if ( parameters.size( ) != 2 )\n {\n throw std::runtime_error( \"Uniform distribution requires two parameters.\" );\n }\n else\n {\n // Create uniform distribution. parameters 0: lower bound, 1: upper bound\n uniform_distribution< > uniformDistribution( parameters.at( 0 ), parameters.at( 1 ) );\n continuousRandomVariable =\n std::make_shared< BoostContinuousProbabilityDistribution< uniform_distribution< > > >(\n uniformDistribution );\n }\n break;\n }\n case normal_boost_distribution:\n {\n // Check number of provided parameters\n if ( parameters.size( ) != 2 )\n {\n throw std::runtime_error( \"Normal distribution requires two parameters.\" );\n }\n else\n {\n // Create uniform distribution. parameters 0: mean, 1: standard deviation\n normal_distribution< > normalDistribution( parameters.at( 0 ), parameters.at( 1 ) );\n continuousRandomVariable =\n std::make_shared< BoostContinuousProbabilityDistribution< normal_distribution< > > >(\n normalDistribution );\n }\n break;\n }\n case exponential_boost_distribution:\n {\n // Check number of provided parameters\n if ( parameters.size( ) != 1 )\n {\n throw std::runtime_error( \"Exponential distribution requires one parameter.\" );\n }\n else\n {\n // Create uniform distribution. parameters 0: lambda parameter\n exponential_distribution< > exponentialDistribution( parameters.at( 0 ) );\n continuousRandomVariable =\n std::make_shared< BoostContinuousProbabilityDistribution< exponential_distribution< > > >(\n exponentialDistribution );\n }\n break;\n }\n case gamma_boost_distribution:\n {\n // Check number of provided parameters\n if ( parameters.size( ) != 2 )\n {\n throw std::runtime_error( \"Gamma distribution requires two parameters.\" );\n }\n else\n {\n // Create uniform distribution. parameters 0: shape parameter, parameter 1: scale parameter\n gamma_distribution< > gammaDistribution( parameters.at( 0 ), parameters.at( 1 ) );\n continuousRandomVariable =\n std::make_shared< BoostContinuousProbabilityDistribution< gamma_distribution< > > >(\n gammaDistribution );\n }\n break;\n }\n case lognormal_boost_distribution:\n {\n // Check number of provided parameters\n if ( parameters.size( ) != 2 )\n {\n throw std::runtime_error( \"Log-normal distribution requires two parameters.\" );\n }\n else\n {\n // Create uniform distribution. parameters 0: location parameter, parameter 1: scale parameter\n lognormal_distribution< > logNormalDistribution( parameters.at( 0 ), parameters.at( 1 ) );\n continuousRandomVariable =\n std::make_shared< BoostContinuousProbabilityDistribution< lognormal_distribution< > > >(\n logNormalDistribution );\n }\n break;\n }\n case beta_boost_distribution:\n {\n // Check number of provided parameters\n if ( parameters.size( ) != 2 )\n {\n throw std::runtime_error( \"Beta distribution requires two parameters.\" );\n }\n else\n {\n // Create uniform distribution. parameters 0: alpha parameter, parameter 1: beta parameter\n beta_distribution< > betaDistribution( parameters.at( 0 ), parameters.at( 1 ) );\n continuousRandomVariable =\n std::make_shared< BoostContinuousProbabilityDistribution< beta_distribution< > > >(\n betaDistribution );\n }\n break;\n }\n default:\n throw std::runtime_error( \"Boost distribution not recognized.\" );\n }\n return continuousRandomVariable;\n}\n\n}\n\n}\n", "meta": {"hexsha": "293bec07764a90fe5082a426fccca8007d4fb834", "size": 5434, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Tudat/Mathematics/Statistics/boostProbabilityDistributions.cpp", "max_stars_repo_name": "ViktorJordanov/tudat", "max_stars_repo_head_hexsha": "069ceeab8f12405c356e19f50d6df037914df85c", "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": "Tudat/Mathematics/Statistics/boostProbabilityDistributions.cpp", "max_issues_repo_name": "ViktorJordanov/tudat", "max_issues_repo_head_hexsha": "069ceeab8f12405c356e19f50d6df037914df85c", "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": "Tudat/Mathematics/Statistics/boostProbabilityDistributions.cpp", "max_forks_repo_name": "ViktorJordanov/tudat", "max_forks_repo_head_hexsha": "069ceeab8f12405c356e19f50d6df037914df85c", "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.7162162162, "max_line_length": 114, "alphanum_fraction": 0.6198012514, "num_tokens": 1051, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392848011834, "lm_q2_score": 0.5621765008857981, "lm_q1q2_score": 0.4969861117751128}} {"text": "#include \n#include \n#include \n#include \n#include \n\n\n#include \n\n// #define USE_SCALAR_IMPLEMENTATION\n#define USE_SSE_IMPLEMENTATION\n#define COMPUTE_V_AS_MATRIX\n#define COMPUTE_U_AS_MATRIX\n\n#include \n\nint main() {\n\n std::ifstream file;\n file.open(\"SVD_benchmark\");\n if (!file) \n {\n CGAL_TRACE_STREAM << \"Error loading file!\\n\";\n return 0;\n }\n\n int ite = 200000;\n Eigen::JacobiSVD svd;\n Eigen::Matrix3d u, v, m, r; \n Eigen::Vector3d w; \n\n int matrix_idx = rand()%200;\n for (int i = 0; i < matrix_idx; i++)\n {\n for (int j = 0; j < 3; j++)\n {\n for (int k = 0; k < 3; k++)\n {\n file >> m(j, k);\n }\n }\n }\n\n\n CGAL::Timer task_timer; \n\n std::cout << \"Start SVD decomposition...\";\n task_timer.start();\n for (int i = 0; i < ite; i++)\n {\n \n #include \n\n ENABLE_SCALAR_IMPLEMENTATION(Sa11.f=m(0,0);) \n ENABLE_SCALAR_IMPLEMENTATION(Sa21.f=m(1,0);) \n ENABLE_SCALAR_IMPLEMENTATION(Sa31.f=m(2,0);) \n ENABLE_SCALAR_IMPLEMENTATION(Sa12.f=m(0,1);) \n ENABLE_SCALAR_IMPLEMENTATION(Sa22.f=m(1,1);) \n ENABLE_SCALAR_IMPLEMENTATION(Sa32.f=m(2,1);) \n ENABLE_SCALAR_IMPLEMENTATION(Sa13.f=m(0,2);) \n ENABLE_SCALAR_IMPLEMENTATION(Sa23.f=m(1,2);) \n ENABLE_SCALAR_IMPLEMENTATION(Sa33.f=m(2,2);) \n\n ENABLE_SSE_IMPLEMENTATION(Va11=_mm_set1_ps(m(0,0));)\n ENABLE_SSE_IMPLEMENTATION(Va21=_mm_set1_ps(m(1,0));)\n ENABLE_SSE_IMPLEMENTATION(Va31=_mm_set1_ps(m(2,0));)\n ENABLE_SSE_IMPLEMENTATION(Va12=_mm_set1_ps(m(0,1));)\n ENABLE_SSE_IMPLEMENTATION(Va22=_mm_set1_ps(m(1,1));)\n ENABLE_SSE_IMPLEMENTATION(Va32=_mm_set1_ps(m(2,1));)\n ENABLE_SSE_IMPLEMENTATION(Va13=_mm_set1_ps(m(0,2));)\n ENABLE_SSE_IMPLEMENTATION(Va23=_mm_set1_ps(m(1,2));)\n ENABLE_SSE_IMPLEMENTATION(Va33=_mm_set1_ps(m(2,2));)\n\n #include \n \n std::pair solver;\n\n#ifdef USE_SCALAR_IMPLEMENTATION\n solver.first(0,0) = Su11.f;\n solver.first(1,0) = Su21.f;\n solver.first(2,0) = Su31.f;\n solver.first(0,1) = Su12.f;\n solver.first(1,1) = Su22.f;\n solver.first(2,1) = Su32.f;\n solver.first(0,2) = Su13.f;\n solver.first(1,2) = Su23.f;\n solver.first(2,2) = Su33.f;\n\n solver.second(0,0) = Sv11.f;\n solver.second(1,0) = Sv21.f;\n solver.second(2,0) = Sv31.f;\n solver.second(0,1) = Sv12.f;\n solver.second(1,1) = Sv22.f;\n solver.second(2,1) = Sv32.f;\n solver.second(0,2) = Sv13.f;\n solver.second(1,2) = Sv23.f;\n solver.second(2,2) = Sv33.f;\n#endif\n\n#ifdef USE_SSE_IMPLEMENTATION\n float buf[4];\n _mm_storeu_ps(buf,Vu11);solver.first(0,0)=buf[0];\n _mm_storeu_ps(buf,Vu21);solver.first(1,0)=buf[0];\n _mm_storeu_ps(buf,Vu31);solver.first(2,0)=buf[0];\n _mm_storeu_ps(buf,Vu12);solver.first(0,1)=buf[0];\n _mm_storeu_ps(buf,Vu22);solver.first(1,1)=buf[0];\n _mm_storeu_ps(buf,Vu32);solver.first(2,1)=buf[0];\n _mm_storeu_ps(buf,Vu13);solver.first(0,2)=buf[0];\n _mm_storeu_ps(buf,Vu23);solver.first(1,2)=buf[0];\n _mm_storeu_ps(buf,Vu33);solver.first(2,2)=buf[0];\n\n _mm_storeu_ps(buf,Vv11);solver.second(0,0)=buf[0];\n _mm_storeu_ps(buf,Vv21);solver.second(1,0)=buf[0];\n _mm_storeu_ps(buf,Vv31);solver.second(2,0)=buf[0];\n _mm_storeu_ps(buf,Vv12);solver.second(0,1)=buf[0];\n _mm_storeu_ps(buf,Vv22);solver.second(1,1)=buf[0];\n _mm_storeu_ps(buf,Vv32);solver.second(2,1)=buf[0];\n _mm_storeu_ps(buf,Vv13);solver.second(0,2)=buf[0];\n _mm_storeu_ps(buf,Vv23);solver.second(1,2)=buf[0];\n _mm_storeu_ps(buf,Vv33);solver.second(2,2)=buf[0];\n#endif\n\n r = solver.first * solver.second.transpose();\n }\n task_timer.stop();\n file.close();\n\n std::cout << \"done: \" << task_timer.time() << \"s\\n\";\n return 0;\n}", "meta": {"hexsha": "137c8ddf245e7201a5ac93e3a0224b1fc0d8219a", "size": 4056, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "graphics/cgal/Surface_mesh_deformation/benchmark/Surface_mesh_deformation/optimal_rotation/optimal_rotation_svd_SSE.cpp", "max_stars_repo_name": "hlzz/dotfiles", "max_stars_repo_head_hexsha": "0591f71230c919c827ba569099eb3b75897e163e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2016-03-30T14:31:52.000Z", "max_stars_repo_stars_event_max_datetime": "2019-02-02T05:01:32.000Z", "max_issues_repo_path": "graphics/cgal/Surface_mesh_deformation/benchmark/Surface_mesh_deformation/optimal_rotation/optimal_rotation_svd_SSE.cpp", "max_issues_repo_name": "hlzz/dotfiles", "max_issues_repo_head_hexsha": "0591f71230c919c827ba569099eb3b75897e163e", "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": "graphics/cgal/Surface_mesh_deformation/benchmark/Surface_mesh_deformation/optimal_rotation/optimal_rotation_svd_SSE.cpp", "max_forks_repo_name": "hlzz/dotfiles", "max_forks_repo_head_hexsha": "0591f71230c919c827ba569099eb3b75897e163e", "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": 31.2, "max_line_length": 116, "alphanum_fraction": 0.6725838264, "num_tokens": 1431, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392848011834, "lm_q2_score": 0.5621765008857981, "lm_q1q2_score": 0.4969861117751128}} {"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\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#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#ifdef ENABLE_PLOTTING\n#include \n#endif\n\n#ifdef ENABLE_ROS\n#include \n#include \n#include \n#include \n#endif\n\nusing namespace std::chrono_literals;\nusing namespace boost::numeric::odeint;\n\nusing Time = std::chrono::duration;\n\ntemplate\nusing X = smooth::Bundle, Eigen::Matrix>;\ntemplate\nusing U = Eigen::Matrix;\n\nusing Xd = X;\nusing Ud = U;\n\nusing Tangentd = smooth::Tangent;\n\nint main()\n{\n // dynamics\n auto f = [](const X & x, const U & u) -> smooth::Tangent> {\n return {\n x.template part<1>().x(),\n x.template part<1>().y(),\n x.template part<1>().z(),\n -S(0.2) * x.template part<1>().x() + u.x(),\n S(0),\n -S(0.4) * x.template part<1>().z() + u.y(),\n };\n };\n\n auto cr = [](const X &, const U & u) -> Eigen::Vector { return u; };\n Eigen::Vector2d crl{-0.5, -0.5};\n Eigen::Vector2d cru{0.5, 0.5};\n\n // simulation time step\n const auto dt = 25ms;\n\n ////////////////////\n //// SET UP MPC ////\n ////////////////////\n\n smooth::feedback::MPC mpc{\n f,\n cr,\n crl,\n cru,\n {.K = 30, .tf = 5},\n };\n\n // define desired trajectory\n auto xdes = [](S t) -> X {\n const Eigen::Vector3d vdes{1, 0, 0.4};\n return X{\n smooth::SE2(smooth::SO2(M_PI_2), Eigen::Vector2(2.5, 0)) + (t * vdes),\n vdes,\n };\n };\n\n mpc.set_weights({\n .Q = Eigen::Matrix::Identity(),\n .Qtf = 0.1 * Eigen::Matrix::Identity(),\n .R = Eigen::Matrix2d::Identity(),\n });\n\n // set desired trajectory in MPC\n mpc.set_xdes_rel(xdes);\n mpc.set_udes_rel([](S) -> U { return U::Zero(); });\n\n /////////////////////\n //// SET UP ASIF ////\n /////////////////////\n\n // safe set\n auto h = [](S, const X & x) -> Eigen::Matrix {\n const Eigen::Vector2 dir = x.template part<0>().r2() - Eigen::Vector2{0, -2.3};\n const Eigen::Vector2d e_dir = dir.template cast().normalized();\n return Eigen::Matrix(dir.dot(e_dir) - 0.7);\n };\n\n // backup controller\n auto bu = [](S, const X & x) -> U {\n return {0.2 * x.template part<1>().x(), -0.5};\n };\n\n const smooth::feedback::ManifoldBounds ulim{\n .A = Eigen::Matrix2d{{1, 0}, {0, 1}},\n .c = Ud::Zero(),\n .l = Eigen::Vector2d(-0.2, -0.5),\n .u = Eigen::Vector2d(0.5, 0.5),\n };\n\n // parameters\n smooth::feedback::ASIFilterParams asif_prm{\n .T = 2.5,\n .nh = 1,\n .u_weight = Eigen::Vector2d{20, 1},\n .ulim = ulim,\n .asif =\n {\n .K = 200,\n .alpha = 5,\n .dt = 0.01,\n .relax_cost = 100,\n },\n .qp =\n {\n .polish = false,\n },\n };\n\n smooth::feedback::ASIFilter asif(f, asif_prm);\n\n /////////////////////////\n //// CREATE ROS NODE ////\n /////////////////////////\n\n#ifdef ENABLE_ROS\n rclcpp::init(0, nullptr);\n auto node = std::make_shared(\"se2_example\");\n auto ses_client = node->create_client(\"/set_entity_state\");\n auto u_mpc_pub =\n node->create_publisher(\"u_mpc\", rclcpp::SystemDefaultsQoS{});\n auto u_asif_pub =\n node->create_publisher(\"u_asif\", rclcpp::SystemDefaultsQoS{});\n\n rclcpp::Rate rate(25ms);\n#endif\n\n /////////////////////////////////////\n //// SIMULATE CLOSED-LOOP SYSTEM ////\n /////////////////////////////////////\n\n // system variables\n Xd x = Xd::Identity();\n Ud u;\n\n // prepare for integrating the closed-loop system\n runge_kutta4 stepper{};\n const auto ode = [&f, &u](const Xd & x, Tangentd & d, double) { d = f(x, u); };\n std::vector tvec, xvec, yvec, u1vec, u2vec, u1mpcvec, u2mpcvec;\n\n // integrate closed-loop system\n for (std::chrono::milliseconds t = 0s; t < 30s; t += dt) {\n // compute MPC input\n const auto [u_mpc, mpc_code] = mpc(t, x);\n if (mpc_code != smooth::feedback::QPSolutionStatus::Optimal) {\n std::cerr << \"MPC failed with mpc_code \" << static_cast(mpc_code) << std::endl;\n }\n\n // filter input with ASIF\n const auto [u_asif, asif_code] = asif(x, u_mpc, h, bu);\n if (asif_code != smooth::feedback::QPSolutionStatus::Optimal) {\n std::cerr << \"ASIF solver failed with asif_code \" << static_cast(asif_code) << std::endl;\n }\n\n // select input\n u = u_asif;\n\n // store data\n tvec.push_back(duration_cast