int Interval::complementary(Interval& c1, Interval& c2) const { if (is_empty() || is_degenerated()) { // x.is_empty() should not happen if called from compl() c1=Interval::ALL_REALS; c2=Interval::EMPTY_SET; return 1; } else { if (lb()>NEG_INFINITY) { c1=Interval(NEG_INFINITY,lb()); if (ub()<POS_INFINITY) { c2=Interval(ub(),POS_INFINITY); return 2; } else { c2=Interval::EMPTY_SET; return 1; } } else if (ub()<POS_INFINITY) { c1=Interval(ub(),POS_INFINITY); c2=Interval::EMPTY_SET; return 1; } else { c1=c2=Interval::EMPTY_SET; return 0; } } }
double TRAC_IK::manipPenalty(const KDL::JntArray& arr) { double penalty = 1.0; for (uint i=0; i< arr.data.size(); i++) { if (types[i] == KDL::BasicJointType::Continuous) continue; double range = ub(i)-lb(i); penalty *= ((arr(i)-lb(i))*(ub(i)-arr(i))/(range*range)); } return std::max(0.0,1.0 - exp(-1*penalty)); }
void lb(no *raiz) { //faz impressão organizada em colchetes if(raiz != NULL) { //mesmo código base da imrpessão pré ordem, já q os primeiros termos representados são os de cima e os da esquerda printf("["); //adiciona um colhete antes de imprimir o numero printf("%d", raiz->chave); lb(raiz->esq); lb(raiz->dir); printf("] "); //fecha o que foi imprimido na execução } else printf("[] "); //se verificado que há um espaço vazio, imprime um colchete vazio }
void TRAC_IK::normalize_limits(const KDL::JntArray& seed, KDL::JntArray& solution) { // Make sure rotational joint values are within 1 revolution of middle of // limits; then ensure joint limits are met. bool improved = false; for (uint i=0; i<lb.data.size(); i++) { if (types[i] == KDL::BasicJointType::TransJoint) continue; double target = seed(i); if (types[i] == KDL::BasicJointType::RotJoint && types[i]!=KDL::BasicJointType::Continuous) target = (ub(i)+lb(i))/2.0; double val = solution(i); if (val > target+M_PI) { //Find actual angle offset double diffangle = fmod(val-target,2*M_PI); // Add that to upper bound and go back a full rotation val = target + diffangle - 2*M_PI; } if (val < target-M_PI) { //Find actual angle offset double diffangle = fmod(target-val,2*M_PI); // Add that to upper bound and go back a full rotation val = target - diffangle + 2*M_PI; } if (types[i]==KDL::BasicJointType::Continuous) { solution(i) = val; continue; } if (val > ub(i)) { //Find actual angle offset double diffangle = fmod(val-ub(i),2*M_PI); // Add that to upper bound and go back a full rotation val = ub(i) + diffangle - 2*M_PI; } if (val < lb(i)) { //Find actual angle offset double diffangle = fmod(lb(i)-val,2*M_PI); // Add that to upper bound and go back a full rotation val = lb(i) - diffangle + 2*M_PI; } solution(i) = val; } }
void TRAC_IK::initialize() { assert(chain.getNrOfJoints()==lb.data.size()); assert(chain.getNrOfJoints()==ub.data.size()); jacsolver.reset(new KDL::ChainJntToJacSolver(chain)); nl_solver.reset(new NLOPT_IK::NLOPT_IK(chain,lb,ub,maxtime,eps,NLOPT_IK::SumSq)); iksolver.reset(new KDL::ChainIkSolverPos_TL(chain,lb,ub,maxtime,eps,true,true)); for (uint i=0; i<chain.segments.size(); i++) { std::string type = chain.segments[i].getJoint().getTypeName(); if (type.find("Rot")!=std::string::npos) { if (ub(types.size())>=std::numeric_limits<float>::max() && lb(types.size())<=std::numeric_limits<float>::lowest()) types.push_back(KDL::BasicJointType::Continuous); else types.push_back(KDL::BasicJointType::RotJoint); } else if (type.find("Trans")!=std::string::npos) types.push_back(KDL::BasicJointType::TransJoint); } assert(types.size()==lb.data.size()); threads.create_thread(boost::bind(&boost::asio::io_service::run, &io_service)); threads.create_thread(boost::bind(&boost::asio::io_service::run, &io_service)); initialized = true; }
void ADMMCut::CalculateX() { // Construct Hessian Matrix for D-Qp problem SpMat Q; CalculateQ(D_, Q); SpMat H2 = Q.transpose() * Q; SpMat H = 2 * H1_ + penalty_ * H2; // Construct Linear coefficient for x-Qp problem a_ = Q.transpose() * lambda_; // Inequality constraints A*x <= b SpMat A(6 * Fd_, 6 * Fd_); A.setZero(); VX b(6 * Fd_); b.setZero(); // Variable constraints x >= lb, x <= ub VX lb(Nd_), ub(Nd_); lb.setZero(); ub.setOnes(); qp_->solve(H, a_, A, b, W_, d_, lb, ub, x_, NULL, NULL, debug_); }
void TestIndPos::testConjugate3() { size_t n = 100; Matrix lb(n, 1); for (size_t i = 0; i < n; i++) { lb[i] = 3.0 + i; } Function * ind_pos = new IndPos(lb); Matrix y(n, 1); double f_star; int status = ind_pos->callConj(y, f_star); _ASSERT(ForBESUtils::is_status_ok(status)); _ASSERT_NUM_EQ(0.0, f_star, 1e-14); y[0] = 1.0; status = ind_pos->callConj(y, f_star); _ASSERT(ForBESUtils::is_status_ok(status)); _ASSERT(std::isinf(f_star)); y[0] = -1.0; y[1] = -2.0; y[2] = -3.0; status = ind_pos->callConj(y, f_star); _ASSERT(ForBESUtils::is_status_ok(status)); _ASSERT_NUM_EQ(-26.0, f_star, 1e-14); delete ind_pos; }
ModEvent SetVarImp::excludeI_full(Space& home, int mi, int ma, I& iterator) { Iter::Ranges::SingletonAppend<I> si(mi,ma,iterator); if (lub.excludeI(home, si)) { BndSetRanges ub(lub); BndSetRanges lb(glb); if (!Iter::Ranges::subset(lb,ub)) { glb.become(home, lub); glb.card(glb.size()); lub.card(glb.size()); return ME_SET_FAILED; } ModEvent me = ME_SET_LUB; if (cardMax() > lub.size()) { lub.card(lub.size()); if (cardMin() > cardMax()) { glb.become(home, lub); glb.card(glb.size()); lub.card(glb.size()); return ME_SET_FAILED; } me = ME_SET_CLUB; } if (cardMax() == lub.size() && cardMin() == cardMax()) { glb.become(home, lub); me = ME_SET_VAL; } SetDelta d; return notify(home, me, d); } return ME_SET_NONE; }
/*--------------------------------------------------------*/ int NOMAD::TGP_Model::filter_and_sort_X (const std::vector<const NOMAD::Eval_Point *> &X , const NOMAD::Point *center , std::list<const NOMAD::Eval_Point *> &filtered_X) const { NOMAD::Point alt_center; const NOMAD::Eval_Point *cur = NULL; int p0 = X.size() , i; // alternate center if center==NULL: if (!center) { int j; NOMAD::Point lb(_n0) , ub(_n0); for (i = 0 ; i < p0 ; ++i) { cur = X[i]; if (test_interpolation_point(cur)) { for (j = 0 ; j < _n0 ; ++j) { if (!lb[j].is_defined() || (*cur)[j] < lb[j]) lb[j] = (*cur)[j]; if (!ub[j].is_defined() || (*cur)[j] > ub[j]) ub[j] = (*cur)[j]; } } } alt_center = NOMAD::Point(_n0); for (j = 0 ; j < _n0 ; ++j) alt_center[j] = (lb[j] + ub[j]) / 2.0; } // X_tmp is used to sort the points: std::multiset<NOMAD::Model_Sorted_Point> tmp_X; for (i = 0 ; i < p0 ; ++i) { cur = X[i]; // test if the interpolation point is valid for interpolation: if (test_interpolation_point(cur)) { NOMAD::Model_Sorted_Point sorted_pt (&NOMAD::Cache::get_modifiable_point(*cur) , (center) ? *center : alt_center); tmp_X.insert(sorted_pt); } } // copy the set X_tmp to filtered_X: std::multiset<NOMAD::Model_Sorted_Point>::const_iterator it , end = tmp_X.end(); for (it = tmp_X.begin() ; it != end ; ++it) filtered_X.push_back(static_cast<NOMAD::Eval_Point *>(it->get_point())); return filtered_X.size(); }
TEST(BoundingBox, Intersection){ Point lb(1,2,0); Point ub(2,4,0); BoundingBox bb1(lb, ub); BoundingBox bb2(lb, ub); // Intersection should return an bounding box equal to bb2 and bb1, // they are the same bb BoundingBox bbIntersection = bb2.intersection(bb1); EXPECT_TRUE( bbIntersection.getLb().getX() == bb2.getLb().getX() && bbIntersection.getLb().getY() == bb2.getLb().getY() && bbIntersection.getLb().getZ() == bb2.getLb().getZ()); EXPECT_TRUE( bbIntersection.getUb().getX() == bb2.getUb().getX() && bbIntersection.getUb().getY() == bb2.getUb().getY() && bbIntersection.getUb().getZ() == bb2.getUb().getZ()); Point lb3(2,3,0); Point ub3(2,4,0); BoundingBox bb3(lb3, ub3); bbIntersection = bb2.intersection(bb3); // lower bound is the value of of bb3 EXPECT_TRUE( bbIntersection.getLb().getX() == lb3.getX() && bbIntersection.getLb().getY() == lb3.getY() && bbIntersection.getLb().getZ() == lb3.getZ()); // upper bound should not change EXPECT_TRUE( bbIntersection.getUb().getX() == bb2.getUb().getX() && bbIntersection.getUb().getY() == bb2.getUb().getY() && bbIntersection.getUb().getZ() == bb2.getUb().getZ()); }
int getmax(int r) { int ret = 0; for(;r;r-=lb(r)) ret = max(ret,p[r]); return ret; }
void glpk_wrapper::set_domain(box const & b) { assert(!b.is_empty()); changed = true; domain = b; for (unsigned int i = 0; i < b.size(); i++) { auto interval = b[i]; double lb = interval.lb(); double ub = interval.ub(); if (lb == NEG_INFINITY) { if (ub == POS_INFINITY) { glp_set_col_bnds(lp, i+1, GLP_FR, lb, ub); } else { glp_set_col_bnds(lp, i+1, GLP_UP, lb, ub); } } else { if (ub == POS_INFINITY) { glp_set_col_bnds(lp, i+1, GLP_LO, lb, ub); } else { if (lb == ub) { glp_set_col_bnds(lp, i+1, GLP_FX, lb, ub); } else { glp_set_col_bnds(lp, i+1, GLP_DB, lb, ub); } } } } }
int getmax(int x,int y) { int ret = 0; for(;x;x-=lb(x)) ret = max(ret,s[x].getmax(y)); return ret; }
bool raycast(game* g, vec2 from, vec2 to) { ivec2 cur(fast_floor(from.x), fast_floor(from.y)); ivec2 end(fast_floor(to.x), fast_floor(to.y)); ivec2 sign(sign(to.x - from.x), sign(to.y - from.y)); vec2 abs_delta(abs(to.x - from.x), abs(to.y - from.y)); vec2 delta_t(vec2(1.0f) / abs_delta); vec2 lb(to_vec2(cur)); vec2 ub(lb + vec2(1.0f)); vec2 t(vec2((from.x > to.x) ? (from.x - lb.x) : (ub.x - from.x), (from.y > to.y) ? (from.y - lb.y) : (ub.y - from.y)) / abs_delta); for(;;) { if (g->is_raycast_solid(cur.x, cur.y)) return true; if (t.x <= t.y) { if (cur.x == end.x) break; t.x += delta_t.x; cur.x += sign.x; } else { if (cur.y == end.y) break; t.y += delta_t.y; cur.y += sign.y; } } return false; }
mga_target_event::mga_target_event( const kep_toolbox::plantes::planet_ptr start, const kep_toolbox::planet::planet_ptr end, const kep_toolbox::epoch t_end, double T_max, bool discount_launcher ):base(6), m_start(start), m_end(end), m_t_end(t_end), m_T_max(T_max), m_discount_launcher(discount_launcher) { // We check that all planets have equal central body if (start->get_mu_central_body() != end->get_mu_central_body()) { pagmo_throw(value_error,"The planets do not all have the same mu_central_body"); } // We check that T_max is positive if (T_max <= 0) { pagmo_throw(value_error,"T_max must be larger than zero"); } // Now setting the problem bounds decision_vector lb(6,0.0), ub(6,1.0); lb[0] = 1.; lb[5] = 1e-5; ub[0] = T_max; ub[2] = 12000.0; ub[5] = 1-1e-5; set_bounds(lb,ub); }
bool core::archive::image_cache::save_all() const { archive::storage_mode mode; mode.flags_.write_ = true; mode.flags_.truncate_ = true; if (!storage_->open(mode)) return false; core::tools::auto_scope lb([this]{ storage_->close(); }); image_vector_t block; for (const auto& image : image_by_msgid_) { block.emplace_back(image.second); if (block.size() >= max_block_size) { if (!serialize_block(*storage_, block)) return false; block.clear(); } } if (!block.empty()) { return serialize_block(*storage_, block); } return true; }
void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray *prhs[]) { if(nrhs!=3 || nlhs != 8) { mexErrMsgIdAndTxt("Drake:testMultipleTimeLinearPostureConstrainttmex:BadInputs","Usage [num_cnst,cnst_val,iAfun,jAvar,A,cnst_name,lb,ub] = testMultipleTimeLinearPostureConstraintmex(kinCnst,q,t)"); } MultipleTimeLinearPostureConstraint* cnst = (MultipleTimeLinearPostureConstraint*) getDrakeMexPointer(prhs[0]); int n_breaks = mxGetNumberOfElements(prhs[2]); double* t_ptr = new double[n_breaks]; memcpy(t_ptr,mxGetPrSafe(prhs[2]),sizeof(double)*n_breaks); int nq = cnst->getRobotPointer()->num_positions; MatrixXd q(nq,n_breaks); if(mxGetM(prhs[1]) != nq || mxGetN(prhs[1]) != n_breaks) { mexErrMsgIdAndTxt("Drake:testMultipleTimeLinearPostureConstraintmex:BadInputs","Argument 2 must be of size nq*n_breaks"); } memcpy(q.data(),mxGetPrSafe(prhs[1]),sizeof(double)*nq*n_breaks); int num_cnst = cnst->getNumConstraint(t_ptr,n_breaks); VectorXd c(num_cnst); cnst->feval(t_ptr,n_breaks,q,c); VectorXi iAfun; VectorXi jAvar; VectorXd A; cnst->geval(t_ptr,n_breaks,iAfun,jAvar,A); std::vector<std::string> cnst_names; cnst->name(t_ptr,n_breaks,cnst_names); VectorXd lb(num_cnst); VectorXd ub(num_cnst); cnst->bounds(t_ptr,n_breaks,lb,ub); VectorXd iAfun_tmp(iAfun.size()); VectorXd jAvar_tmp(jAvar.size()); for(int i = 0;i<iAfun.size();i++) { iAfun_tmp(i) = (double) iAfun(i)+1; jAvar_tmp(i) = (double) jAvar(i)+1; } plhs[0] = mxCreateDoubleScalar((double) num_cnst); plhs[1] = mxCreateDoubleMatrix(num_cnst,1,mxREAL); memcpy(mxGetPrSafe(plhs[1]),c.data(),sizeof(double)*num_cnst); plhs[2] = mxCreateDoubleMatrix(iAfun_tmp.size(),1,mxREAL); memcpy(mxGetPrSafe(plhs[2]),iAfun_tmp.data(),sizeof(double)*iAfun_tmp.size()); plhs[3] = mxCreateDoubleMatrix(jAvar_tmp.size(),1,mxREAL); memcpy(mxGetPrSafe(plhs[3]),jAvar_tmp.data(),sizeof(double)*jAvar_tmp.size()); plhs[4] = mxCreateDoubleMatrix(A.size(),1,mxREAL); memcpy(mxGetPrSafe(plhs[4]),A.data(),sizeof(double)*A.size()); int name_ndim = 1; mwSize name_dims[] = {(mwSize) num_cnst}; plhs[5] = mxCreateCellArray(name_ndim,name_dims); mxArray *name_ptr; for(int i = 0;i<num_cnst;i++) { name_ptr = mxCreateString(cnst_names[i].c_str()); mxSetCell(plhs[5],i,name_ptr); } plhs[6] = mxCreateDoubleMatrix(num_cnst,1,mxREAL); plhs[7] = mxCreateDoubleMatrix(num_cnst,1,mxREAL); memcpy(mxGetPrSafe(plhs[6]),lb.data(),sizeof(double)*num_cnst); memcpy(mxGetPrSafe(plhs[7]),ub.data(),sizeof(double)*num_cnst); delete[] t_ptr; }
double Interval::delta(const Interval& x) const { if (is_empty()) return 0; if (x.is_empty()) return diam(); // ** warning ** // checking if *this or x is infinite by // testing if the lower/upper bounds are -oo/+oo // is not enough because diam() may return +oo even // with finite bounds (e.g, very large intervals like [-DBL_MAX,DBL_MAX]). // ("almost-unboundedness") volatile double d=diam(); volatile double dx=x.diam(); // furthermore, if these variables are not declared volatile // conditions like d==POS_INFINITY are evaluated // to FALSE for intervals like [-DBL_MAX,DBL_MAX] (with -O3 option) // while the returned expression (d-dx) evaluates to +oo (instead of 0). if (d==POS_INFINITY) { //cout << "d=" << d << " dx=" << dx << endl; if (dx==POS_INFINITY) { double left=(x.lb()==NEG_INFINITY? 0 : x.lb()-lb()); double right=(x.ub()==POS_INFINITY? 0 : ub()-x.ub()); //cout << "left=" << left << " right=" << right << endl; return left+right; } else return POS_INFINITY; } else return d-dx; }
int getsum(int r) { int ret = 0; for (int i = r; i >= 0; i -= lb(i)) { ret += sum[i]; } return ret; }
int FiberMeshFairing::solveLaplacianCurvatureEnerge() { std::vector< Scalar > lb(mesh_->n_vertices_()); std::vector< Scalar > x(mesh_->n_vertices_()); if(!ls_laplacian_solver_->solve(lb,c_,x)) { return 0; } Scalar re = 0; Scalar total = 0; for(size_t i=0; i < c_.size(); i++) { re += sqrt( (c_[i] - x[i]) * (c_[i] - x[i])); total += sqrt(c_[i] * c_[i]); } DebugLog<<re / total <<std::endl; if(re < total * tolerance_) { return -1; } c_.clear(); for(size_t i=0; i < mesh_->n_vertices_(); i++) { c_.push_back(x[i]); } return 1; }
void demography :: EndContact(b2Contact* contact) { bool A = contact->GetFixtureA()->IsSensor(); bool B = contact->GetFixtureB()->IsSensor(); if(A ^ B) { lb("sens",432); //auto // bodyA = contact->GetFixtureA()->GetBody(), // bodyB = contact->GetFixtureB()->GetBody(); //auto // ga = contact->GetFixtureA()->GetFilterData().groupIndex, // gb = contact->GetFixtureB()->GetFilterData().groupIndex; //if(ga && gb) //{ // nears[bodyA] .erase(bodyB); // nears[bodyB] .erase(bodyA); //} //else //{ // if(A) targets.erase(bodyA); // else targets.erase(bodyB); //} } }
void ofxMesh::addFace(ofRectangle r) { ofVec2f lt(r.x,r.y); ofVec2f rt(r.x+r.width,r.y); ofVec2f rb(r.x+r.width,r.y+r.height); ofVec2f lb(r.x,r.y+r.height); addFace(lt,lb,rb,rt); }
bool One::foundUnsat() { ++numberOfCalls; const Clause* core = solver.getUnsatCore(); assert( core != NULL ); const Clause& unsatCore = *( core ); //The incoherence does not depend on weak constraints if( unsatCore.size() == 0 ) return false; solver.clearConflictStatus(); solver.unrollToZero(); for( unsigned int i = 0; i < unsatCore.size(); i++ ) visit( unsatCore[ i ].getVariable() ); vector< Literal > literals; vector< uint64_t > weights; unsigned int n = 0; uint64_t minWeight = computeMinWeight(); if( !processCoreOne( literals, weights, minWeight, n ) || !addAggregateOne( literals, weights, n + 1 ) ) return false; incrementLb( minWeight ); solver.foundLowerBound( lb() ); return true; }
void dfs(int now){ if( now==n-1 ){ int c = (1<<n) - 1 - x; if( !illegal(c) ) ++ans; } else { int less = (1<<n)-1-x; while( less ){ int c = lb(less); less-=c; if( illegal(c) ) continue; else { x+=c; z+=c<<now; s+=c<<(n-now-1); dfs(now+1); x-=c; z-=c<<now; s-=c<<(n-now-1); } } } }
bool OsiRowCut::infeasible(const OsiSolverInterface &) const { if (lb() > ub()) return true; return false; }
int getsum(int dep,int tx,int ty) { int x = dep; sum = 0; for(; x; x -= lb(x)) query(c[x],1,n,tx,ty); return sum; }
void Type_Contiguous::unserialize(const void* contiguous_buf, void* noncontiguous_buf, int count, MPI_Op op) { const char* contiguous_buf_char = static_cast<const char*>(contiguous_buf); char* noncontiguous_buf_char = static_cast<char*>(noncontiguous_buf)+lb(); int n= count*block_count_; if(op!=MPI_OP_NULL) op->apply( contiguous_buf_char, noncontiguous_buf_char, &n, old_type_); }
void mexFunction(int nlhs,mxArray* plhs[], int nrhs, const mxArray * prhs[]) { if(nrhs!=3 || nlhs != 7) { mexErrMsgIdAndTxt("Drake:testMultipleTimeKinCnstmex:BadInputs","Usage [type,num_cnst,cnst_val,dcnst_val,cnst_name,lb,ub] = testMultipleTimeKinCnstmex(kinCnst,q,t)"); } MultipleTimeKinematicConstraint* cnst = (MultipleTimeKinematicConstraint*) getDrakeMexPointer(prhs[0]); int n_breaks = mxGetNumberOfElements(prhs[2]); double* t_ptr = new double[n_breaks]; memcpy(t_ptr,mxGetPrSafe(prhs[2]),sizeof(double)*n_breaks); int nq = cnst->getRobotPointer()->num_positions; MatrixXd q(nq,n_breaks); if(mxGetM(prhs[1]) != nq || mxGetN(prhs[1]) != n_breaks) { mexErrMsgIdAndTxt("Drake:testMultipleTimeKinCnstmex:BadInputs","Argument 2 must be of size nq*n_breaks"); } memcpy(q.data(),mxGetPrSafe(prhs[1]),sizeof(double)*nq*n_breaks); int type = cnst->getType(); int num_cnst = cnst->getNumConstraint(t_ptr,n_breaks); VectorXd c(num_cnst); MatrixXd dc(num_cnst,nq*n_breaks); cnst->eval(t_ptr,n_breaks,q,c,dc); VectorXd lb(num_cnst); VectorXd ub(num_cnst); cnst->bounds(t_ptr,n_breaks,lb,ub); std::vector<std::string> cnst_names; cnst->name(t_ptr,n_breaks,cnst_names); int retvec_size; if(num_cnst == 0) { retvec_size = 0; } else { retvec_size = 1; } plhs[0] = mxCreateDoubleScalar((double) type); plhs[1] = mxCreateDoubleScalar((double) num_cnst); plhs[2] = mxCreateDoubleMatrix(num_cnst,retvec_size,mxREAL); memcpy(mxGetPrSafe(plhs[2]),c.data(),sizeof(double)*num_cnst); plhs[3] = mxCreateDoubleMatrix(num_cnst,nq*n_breaks,mxREAL); memcpy(mxGetPrSafe(plhs[3]),dc.data(),sizeof(double)*num_cnst*nq*n_breaks); int name_ndim = 1; mwSize name_dims[] = {(mwSize) num_cnst}; plhs[4] = mxCreateCellArray(name_ndim,name_dims); mxArray *name_ptr; for(int i = 0;i<num_cnst;i++) { name_ptr = mxCreateString(cnst_names[i].c_str()); mxSetCell(plhs[4],i,name_ptr); } plhs[5] = mxCreateDoubleMatrix(num_cnst,retvec_size,mxREAL); plhs[6] = mxCreateDoubleMatrix(num_cnst,retvec_size,mxREAL); memcpy(mxGetPrSafe(plhs[5]),lb.data(),sizeof(double)*num_cnst); memcpy(mxGetPrSafe(plhs[6]),ub.data(),sizeof(double)*num_cnst); delete[] t_ptr; }
//----------------------------------------------------------------------------------------------------- bool miner::find_nonce_for_given_block(crypto::cn_context &context, Block& bl, const difficulty_type& diffic) { unsigned nthreads = std::thread::hardware_concurrency(); if (nthreads > 0 && diffic > 5) { std::vector<std::future<void>> threads(nthreads); std::atomic<uint32_t> foundNonce; std::atomic<bool> found(false); uint32_t startNonce = crypto::rand<uint32_t>(); for (unsigned i = 0; i < nthreads; ++i) { threads[i] = std::async(std::launch::async, [&, i]() { crypto::cn_context localctx; crypto::hash h; Block lb(bl); // copy to local block for (uint32_t nonce = startNonce + i; !found; nonce += nthreads) { lb.nonce = nonce; if (!get_block_longhash(localctx, lb, h)) { return; } if (check_hash(h, diffic)) { foundNonce = nonce; found = true; return; } } }); } for (auto& t : threads) { t.wait(); } if (found) { bl.nonce = foundNonce.load(); } return found; } else { for (; bl.nonce != std::numeric_limits<uint32_t>::max(); bl.nonce++) { crypto::hash h; if (!get_block_longhash(context, bl, h)) { return false; } if (check_hash(h, diffic)) { return true; } } } return false; }
void cScSetup::Store(bool AsIs) { if(ScOpts) ScOpts->Store(AsIs); cSystems::ConfigStore(AsIs); if(LogOpts) LogOpts->Store(AsIs); cLineBuff lb(128); if(cLogging::GetConfig(&lb)) ScPlugin->SetupStore("LogConfig",lb.Line()); }