自学教程：C++ FILE_LOG函数代码示例

/** * * Execute the best play * * */zet Agent::play(board& b,bool player){	this->playing_color = player;	if (lapse(get_generator())){		std::vector<zet> s = enumerate_moves(b,player); 		int rn_n = std::uniform_int_distribution<int>(0,s.size()-1)(get_generator());		FILE_LOG(logDEBUG)<<" * lapsing - returning random move" <<std::endl;		return s[rn_n];	}	std::vector<zet> s = solve(b,player); 	FILE_LOG(logDEBUG)<<"Playing for player "<<((player==BLACK)?"BLACK":"WHITE")<< " there are "<< s.size() <<" moves" << std::endl;	FILE_LOG(logDEBUG)<<" board is :" <<b<<std::endl;	if(s.empty()){		FILE_LOG(logERROR)<<" board with no moves "<<b <<std::endl;	}	assert(!s.empty());	zet r;	//std::random_shuffle(s.begin(),s.end());	if (player == BLACK || is_negamax()){		r=*std::max_element(s.begin(),s.end(),[](const zet& z1, const zet& z2 ){ return z1.val < z2.val;});	} else{		r=*std::min_element(s.begin(),s.end(),[](const zet& z1, const zet& z2 ){ return z1.val < z2.val;});	}	FILE_LOG(logDEBUG)<<((player==BLACK)?"BLACK":"WHITE")<<" playes move "<<r.zet_id<<" with value:"<<r.val <<std::endl;	return r;}

void CPortmap::freePorts(San2::Utils::CProducerConsumer<std::shared_ptr<San2::Network::CCapsule> > *applicationQueue){    FILE_LOG(logDEBUG4) << "CPortmap::freePorts():: freeing ports /n";    // thanks to http://stackoverflow.com/questions/4600567/c-deleting-elements-with-iterator    std::function<bool (std::pair<unsigned short int, San2::Utils::CProducerConsumer<std::shared_ptr<San2::Network::CCapsule> >*>)> shouldDelete = [applicationQueue] (std::pair<unsigned short int, San2::Utils::CProducerConsumer<std::shared_ptr<San2::Network::CCapsule> >*> pair) -> bool    {        return pair.second == applicationQueue;    };    std::map<unsigned short int, San2::Utils::CProducerConsumer<std::shared_ptr<San2::Network::CCapsule> >*>::iterator itr = mapPorts.begin();    while (itr != mapPorts.end())    {        if (shouldDelete(*itr))        {            std::map<unsigned short int, San2::Utils::CProducerConsumer<std::shared_ptr<San2::Network::CCapsule> >*>::iterator toErase = itr;            ++itr;            mapPorts.erase(toErase);            FILE_LOG(logDEBUG4) << "CPortmap::freePorts():: port has been freed OK/n";        }        else        {            ++itr;        }    }}

void ColaTopologyAddon::handleResizes(const cola::Resizes& resizeList,        unsigned n, std::valarray<double>& X, std::valarray<double>& Y,         cola::CompoundConstraints& ccs, vpsc::Rectangles& boundingBoxes,        cola::RootCluster* clusterHierarchy){    FILE_LOG(cola::logDEBUG) << "ColaTopologyAddon::handleResizes()...";    if(topologyNodes.empty()) {        COLA_ASSERT(topologyRoutes.empty());        return;    }    // all shapes to be resized are wrapped in a ResizeInfo and    // placed in a lookup table, resizes, indexed by id    ResizeMap resizes;    for(cola::Resizes::const_iterator r=resizeList.begin();r!=resizeList.end();++r) {        topology::ResizeInfo ri(topologyNodes[r->getID()],r->getTarget());        resizes.insert(std::make_pair(r->getID(),ri));    }    vpsc::Variables xvs, yvs;    vpsc::Constraints xcs, ycs;    cola::setupVarsAndConstraints(n, ccs, vpsc::HORIZONTAL, boundingBoxes,            clusterHierarchy, xvs, xcs, X);    cola::setupVarsAndConstraints(n, ccs, vpsc::VERTICAL, boundingBoxes,            clusterHierarchy, yvs, ycs, Y);    topology::applyResizes(topologyNodes, topologyRoutes, clusterHierarchy,            resizes, xvs, xcs, yvs, ycs);    for_each(xvs.begin(), xvs.end(), delete_object());    for_each(yvs.begin(), yvs.end(), delete_object());    for_each(xcs.begin(), xcs.end(), delete_object());    for_each(ycs.begin(), ycs.end(), delete_object());    FILE_LOG(cola::logDEBUG) << "ColaTopologyAddon::handleResizes()... done.";}

bool CommonAPI::InitAS(){	engine = asCreateScriptEngine(ANGELSCRIPT_VERSION);	engine->SetMessageCallback(asFUNCTION(MessageCallback), 0, asCALL_CDECL);	RegisterStdString(engine);	RegisterAPI();	CScriptBuilder builder;	if(builder.StartNewModule(engine, "MyModule") < 0)		FILE_LOG(logERROR) << "Unrecoverable error while starting a new module.";	string scriptPath = exePath.substr(0, exePath.find_last_of(".")).append(".tes");	if(builder.AddSectionFromFile(scriptPath.c_str()) < 0)		FILE_LOG(logERROR) << "Unable to load script." << scriptPath;	else		FILE_LOG(logINFO) << "Script " << scriptPath << " loaded successfully.";	if(builder.BuildModule() < 0)		FILE_LOG(logERROR) << "Please correct the errors in the script and try again.";		module = engine->GetModule("MyModule");	return true;}

Measurement::Measurement(Picoscope *p){	FILE_LOG(logDEBUG3) << "Measurement::Measurement (Picoscope=" << p << ")";	int i;	picoscope = p;	trigger = NULL;	is_triggered = false;	max_memory_consumption    = 0;	max_trace_length_to_fetch = 0;	ntraces = 1;	max_traces_to_fetch = 1;	timebase_reported_by_osciloscope = 0.0;	use_signal_generator = false;	rate_per_second = 0.0;	for(i=0; i<GetNumberOfChannels(); i++) {		// initialize the channels		FILE_LOG(logDEBUG4) << "Measurement::Measurement - initialize channel nr. " << i;		channels[i]=new Channel(i, this);		data[i] = NULL;		data_allocated[i] = false;		data_length[i] = 0;	}	// only a temporary setting; this needs to be fixed if more than a single channel is enabled	timebase = 0UL;}

FeedbackState::FeedbackState(const string &text): answer("", App::white, 1, TXT_BLEND), suggestion("", App::white, 1, TXT_BLEND){	name = "Feedback";	instruction = string("Press Enter to Continue.");//	this->text = string(text);		FILE_LOG(logDEBUG3) << "FeedbackState cstruct " << text;	result = App::get()->judge.calcScore(text);	/*	screen_text.push_back(Text(text, App::white));	screen_text.push_back(Text(result.answer, App::white));	screen_text.push_back(Text(result.suggestion, App::white));	*///	FILE_LOG(logDEBUG3) << "FeedbackState cstruct " << screen_text[1].getText();	stringstream s;	s << "Score: " << result.score;	caption.setText(s.str());		answer.setText(result.answer);	suggestion.setText(result.suggestion);	FILE_LOG(logDEBUG3) << "FeedbackState cstruct " << caption.getText();	App::get()->judge.talk = 600;	App::get()->judge.head_nod = 700 -2*result.score;	}

void Store::_initDB(){    string connectionString = string(_ndbConnectString) + ":" + to_string(_ndbPort);    setenv("NDB_CONNECTSTRING", connectionString.c_str(), 1);        ndb_init();    //_mysql.reset(new MYSQL[_noExecutorThreads], ArrayDeleter<MYSQL>());    _clusterConnections.reset(new Ndb_cluster_connection[_totalClusterConnections], ArrayDeleter<Ndb_cluster_connection>());    for (int i = 0; i < _totalClusterConnections; i++)    {        if(_clusterConnections.get()[i].connect(12, 5, 1) != 0)        {            FILE_LOG(logERROR)<<"Failed to connect to ndb cluster connection no "<<i+1;            exit(EXIT_FAILURE);        }    }       FILE_LOG(logINFO)<<"Initialzing NDB ";    //    _initNDB(_ndbDefiners, _noDefinerThread);    _initNDB(_ndbExecutors, _noExecutorThreads);       FILE_LOG(logINFO)<<"NDB Initialzed";        NDBMessageExecutor::initialize(_mysql.get(), _ndbExecutors.get(), &_tableInfoCache);//    NDBMessageProcessor::initialize(_ndbDefiners.get(), &_tableInfoCache);}

  void MCMCModel::setCriteria(randEngine& eng)  {    CriteriaFactory mCFactory;    for(size_t i = 0; i<nParticles; ++i)      {	mCrit.push_back(mCFactory.create(mParameters.crit_name,&mGP[i]));	mCrit[i].setRandomEngine(eng);	if (mCrit[i].nParameters() == mParameters.crit_params.size())	  {	    mCrit[i].setParameters(mParameters.crit_params);	  }	else // If the number of parameters is different, use default.	  {	    if (mParameters.crit_params.size() != 0)	      {		FILE_LOG(logERROR) << "Expected " << mCrit[i].nParameters() 				   << " parameters. Got " 				   << mParameters.crit_params.size() << " instead.";	      }	    FILE_LOG(logINFO) << "Using default parameters for criteria.";	  }      }  } // setCriteria

void Consensus::initialize(const vector<Point2f> & points_normalized){    FILE_LOG(logDEBUG) << "Consensus::initialize() call";    //Copy normalized points    this->points_normalized = points_normalized;    size_t num_points = points_normalized.size();    //Create matrices of pairwise distances/angles    distances_pairwise = Mat(num_points, num_points, CV_32FC1);    angles_pairwise = Mat(num_points, num_points, CV_32FC1);    for (size_t i = 0; i < num_points; i++)    {        for (size_t j = 0; j < num_points; j++)        {            Point2f v = points_normalized[i] - points_normalized[j];            float distance = norm(v);            float angle = atan2(v.y,v.x);            distances_pairwise.at<float>(i,j) = distance;            angles_pairwise.at<float>(i,j) = angle;        }    }    FILE_LOG(logDEBUG) << "Consensus::initialize() return";}

int main(int argc, char* argv[]){  try    {      // levels: logERROR, logWARNING, logINFO, logDEBUG,       // logDEBUG1, logDEBUG2, logDEBUG3, logDEBUG4            //      // Set a reporting level      //      FILELog::ReportingLevel() = FILELog::FromString("DEBUG4");      //      // Set an output file      //      FILE* pFile = fopen("application.log", "a");      Output2FILE::Stream() = pFile;      const int count = 3;      FILE_LOG(logDEBUG) << "A loop with " << count << " iterations";      for (int i = 0; i != count; ++i)        {	  FILE_LOG(logDEBUG1) << "the counter i = " << i;        }      return 0;    }  catch(const std::exception& e)    {      FILE_LOG(logERROR) << e.what();    }  return -1;}

int bayes_optimization_disc(int nDim, eval_func f, void* f_data,			    double *valid_x, size_t n_points,			    double *x, double *minf, bopt_params parameters){  vectord result(nDim);  vectord input(nDim);  vecOfvec xSet;  for(size_t i = 0; i<n_points;++i)    {      for(int j = 0; j<nDim; ++j)	{	 input(j) = valid_x[i*nDim+j]; 	}      xSet.push_back(input);    }  if(parameters.n_init_samples > n_points)    {      parameters.n_init_samples = n_points;      parameters.n_iterations = 0;    }  try    {      CDiscreteModel optimizer(xSet,parameters);            optimizer.set_eval_funct(f);      optimizer.save_other_data(f_data);      optimizer.optimize(result);      std::copy(result.begin(), result.end(), x);      *minf = optimizer.getValueAtMinimum();    }  catch (std::bad_alloc& e)    {      FILE_LOG(logERROR) << e.what();       return  BAYESOPT_OUT_OF_MEMORY;     }  catch (std::invalid_argument& e)    {       FILE_LOG(logERROR) << e.what();       return BAYESOPT_INVALID_ARGS;     }  catch (std::runtime_error& e)    {       FILE_LOG(logERROR) << e.what();       return BAYESOPT_RUNTIME_ERROR;    }  catch (...)    {       FILE_LOG(logERROR) << "Unknown error";      return BAYESOPT_FAILURE;     }  return 0; /* everything ok*/}

	// TODO: socket closing in open() and receive(), add cleanup() and destructor again	TcpErrorCode CTcpClient::open()	{		if (m_sock != SNET_BADSOCKET) SNET_SOCKCLOSE(m_sock);		m_sock = SNET_BADSOCKET;		struct addrinfo hints, *servinfo, *p;		int ret;		memset(&hints, 0, sizeof hints);		hints.ai_family = AF_INET; // force IPv4		hints.ai_socktype = SOCK_STREAM;		if ((ret = getaddrinfo(m_ip.c_str(), m_port.c_str(), &hints, &servinfo)) != 0) 		{            #ifdef LINUX			    FILE_LOG(logDEBUG3) << "CTcpClient::open():getaddrinfo: " << gai_strerror(ret);            #endif            #ifdef WINDOWS                FILE_LOG(logDEBUG3) << "CTcpClient::open():getaddrinfo: WSAGetLastError() " <<  WSAGetLastError();            #endif			return TcpErrorCode::FAILURE;		}		// loop through all the results and connect to the first we can		for(p = servinfo; p != NULL; p = p->ai_next) 		{			if ((m_sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) 			{				FILE_LOG(logDEBUG3) << "CTcpClient::open():socket()" << strerror(errno);				continue;			}			if (connect(m_sock, p->ai_addr, p->ai_addrlen) == -1) 			{				san_cleanup_socket(&m_sock);				// perror("client: connect");				continue;			}			break;		}		if (p == NULL) 		{			// FILE_LOG(logDEBUG3) << "CTcpClient::open(): failed to connect";			san_cleanup_socket(&m_sock);			return TcpErrorCode::FAILURE;		}		// inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr), s, sizeof s);		// printf("client: connecting to %s/n", s);		freeaddrinfo(servinfo); // all done with this structure		//close(m_sock);		return TcpErrorCode::SUCCESS;	}

	void CLIENT::netHandler::connect(char *remoteIPAddress, unsigned short serverPort) {		FILE_LOG(logINFO) << "Connecting to " << remoteIPAddress << ":" << serverPort;		bool tryingToConnect;		tryingToConnect = peer->Connect(remoteIPAddress, serverPort, 0, 0, 0) == RakNet::CONNECTION_ATTEMPT_STARTED;		if (tryingToConnect == false)		{			FILE_LOG(logINFO) << "Client wont start connecting?";		}	}

Agent* Agent_builder::create_instance(std::string type){	FILE_LOG(logDEBUG) << " Creating instance of agent from type "<<type<<std::endl;	if (agent_constructors.find(type)==agent_constructors.end()){		FILE_LOG(logERROR)<< " Cannot create agent of type ["<<type<<"]"<< std::endl;		exit(-1);	}	Agent *a=agent_constructors[type]();	return a;}

/*** * Look for the values of ?? and fills it with the relevant data * Suggestion: ?<index>{lower,upper} * */inline void concrete(Agent_params& ap,double* paramptr){	FILE_LOG(logDEBUG) << "starting concrete " << std::endl;	for (properties::iterator i = ap.m_properties.begin(); i != ap.m_properties.end(); ++i) {		if(is_concrete_param(i->second)){			FILE_LOG(logDEBUG) << "need to concrete: ["<<i->first << "] with value:" << i->second<< std::endl; 			ap.m_properties[i->first]=assigned_val(i->second,paramptr);			FILE_LOG(logDEBUG) << " concrete-assgined ("<< ap.m_properties[i->first]<<")"<< std::endl;	       	}	}}

FkInt32S FkSilhDetector_PaintedFlies::segmentFrame(const IplImage *thisFrame) // I want to keep it void{    FILE_LOG(logDEBUG1)<< "/nbegin of FkSilhDetector_PaintedFlies::segmentFrame";    if(m_isInited!=1)    {        FILE_LOG(logDEBUG1)<< "/nsilhDetector is not init";        return(FK_ERR_SILH_DETECT_IS_NOT_INIT);    }    CvPoint pt1, pt2; //this is for ROI, TODO: get this exposed     pt1 = cvPoint(1,1);    pt2 = cvPoint(thisFrame->width, thisFrame->height); //setting ROI the whole image    cvZero(m_rawChangeMask);    int i, j, minX,maxX,minY,maxY;    minX = FK_MIN(pt1.x, pt2.x);    maxX = FK_MAX(pt1.x, pt2.x);    minY = FK_MIN(pt1.y, pt2.y);    maxY = FK_MAX(pt1.y, pt2.y);#if __USE_OPENMP_FOR_SEGMENTATION#pragma omp parallel shared(i,j,maxX,maxY,minX,minY)//, thisFrame, m_bgModel, m_threshold, m_rawChangeMask)    {#pragma omp for schedule(dynamic)#endif    for(i= minY+1; i<maxY-1; ++i) //just look for silhouettes in ROI    {        for(j=minX+1; j<maxX-1; ++j)        {                        if( pixelDistance( &UPIXEL(thisFrame, i, j, 0), &UPIXEL(m_bgModel, i, j, 0), 3 ) > -m_threshold )            {                //for(int k = 0; k < m_bgModel->nChannels; ++k)                //{                //    //if (parentCamView->frameNum % 1000 == 0)                //    //    UPIXEL(m_bgModel, i, j, k) = (unsigned char) (alpha * UPIXEL(thisFrame, i, j, k) + (1-alpha) * UPIXEL(m_bgModel, i, j, k));                //}            }            else            {                PIXEL(m_rawChangeMask,i, j, 0) |= 0xFF;            }        }    }#if __USE_OPENMP_FOR_SEGMENTATION    }#endif    FILE_LOG(logDEBUG1)<< "/nEnd of FkSilhDetector_PaintedFlies::segmentFrame";    return (FK_OK);}

  void checkNLOPTerror(nlopt_result errortype)  {    switch(errortype)      {      case -1: FILE_LOG(logERROR) << "NLOPT: General failure"; break;      case -2: FILE_LOG(logERROR) << "NLOPT: Invalid arguments. Check bounds."; break;      case -3: FILE_LOG(logERROR) << "NLOPT: Out of memory"; break;      case -4: FILE_LOG(logERROR) << "NLOPT Warning: Potential roundoff error. " 				  << "In general, this can be ignored."; break;      case -5: FILE_LOG(logERROR) << "NLOPT: Force stop."; break;      default: ;      }  }

  void DiscreteModel::plotStepData(size_t iteration, const vectord& xNext,				   double yNext)  {    if(mParameters.verbose_level >0)      { 	FILE_LOG(logINFO) << "Iteration: " << iteration+1 << " of " 			  << mParameters.n_iterations << " | Total samples: " 			  << iteration+1+mParameters.n_init_samples ;	FILE_LOG(logINFO) << "Trying point at: " << xNext ;	FILE_LOG(logINFO) << "Current outcome: " << yNext ;	FILE_LOG(logINFO) << "Best found at: " << getPointAtMinimum() ; 	FILE_LOG(logINFO) << "Best outcome: " <<  getValueAtMinimum() ;          }  }

void Store::_executorWorkerThreadFunc(unsigned short threadNo){    try    {        initMySQL(&_mysql.get()[threadNo], threadNo);                zmq::socket_t taskReceiverSocket(*_serverTransport->getContext(), ZMQ_PULL);        taskReceiverSocket.bind(TransportUtils::getSinkName(_EXECUTOR_SINK_NAME, threadNo).c_str());                zmq::socket_t taskSenderSocket(*_serverTransport->getContext(), ZMQ_PUSH);        taskSenderSocket.connect(TransportUtils::getSinkName(ServerTransport::SERVER_SINK_NAME, threadNo%_noDefinerThread).c_str());        const int TASK_RECEIVER_SOCKET_INDEX = 0;        const int TOTAL_POLL_ITEMS = 1;        const int POLL_WAIT_MS = _storePollWait;                FILE_LOG(logINFO)<<"Initialized executor worker # "<<threadNo;        addExecutorInitializationCount();                zmq::pollitem_t items[] = {            {taskReceiverSocket, 0, ZMQ_POLLIN, 0},        };                while(true)        {            if(_stopFlag)                break;            //            zmq::poll(items, TOTAL_POLL_ITEMS, POLL_WAIT_MS);                        std::this_thread::sleep_for(chrono::milliseconds(10));            //            if (items[TASK_RECEIVER_SOCKET_INDEX].revents & ZMQ_POLLIN)            {                auto messages = TransportUtils::receiveQueuedMessages(taskReceiverSocket, _MAX_TRANSACTIONS);                if(messages.size() > 0)                {//                FILE_LOG(logINFO)<<"Received: ";                    _executeMessages(messages, taskSenderSocket, threadNo);                }            }        }    }    catch(exception& ex)    {        FILE_LOG(logERROR)<<"EXCEPTION IN EXECUTOR WORKER # "<<threadNo<<": "<<ex.what();    }}

/************************************************************************************************** *  Procedure                                                                                     * *                                                                                                * *  Description: operator()                                                                       * *  Class      : UnscentedExpectedImprovement                                                     * **************************************************************************************************/double UnscentedExpectedImprovement::operator() (const vectord& x){    double               e_uei = 0.0;    double               d_uei = 0.0;    std::vector<double > ei_i;    std::vector<vectord> xx;                         xx.push_back(x);    // Calculate query_i    for (size_t column = 0; column < _px.size2(); ++column)    {        xx.push_back(x - boost::numeric::ublas::column(_px, column));        xx.push_back(x + boost::numeric::ublas::column(_px, column));    }    // Calculate EI_i and E[UEI]    for (size_t idx = 0; idx < xx.size(); ++idx)    {        // Calculate ei_i according to underlying _criteria        ei_i.push_back( (*_criteria)(xx[idx]) );        FILE_LOG(logDEBUG) << "cUEI Query " << idx << " = " << xx[idx];        // e_uei = sum_{i=0}^{2_dim+1} (ei_i * w_i)        if (idx == 0) e_uei += ei_i[idx] * ( _scale / (_dim + _scale) );        else          e_uei += ei_i[idx] * (  0.5   / (_dim + _scale) );    }    // Normalize e_uei    e_uei /= xx.size();    // Calculate V[UEI]    for (size_t idx = 0; idx < xx.size(); idx += 1)    {        // d_uei = sum_{i=0}^{2_dim+1} ( (ei_i-e_uei)^2 * w_i)        if (idx == 0) d_uei += ( ei_i[idx] - e_uei ) * ( ei_i[idx] - e_uei ) * ( _scale / (_dim + _scale) );        else          d_uei += ( ei_i[idx] - e_uei ) * ( ei_i[idx] - e_uei ) * (  0.5   / (_dim + _scale) );    }    // Normalize d_uei    d_uei  = std::sqrt(d_uei / xx.size());    FILE_LOG(logDEBUG) << "e_uei = " << e_uei;    FILE_LOG(logDEBUG) << "d_uei = " << d_uei;    // Return criteria    return ( ((1 -_alpha) * e_uei) - (_alpha * d_uei) );}

U2VertexShader::U2VertexShader(const U2DynString& szShadername)	:U2Shader(szShadername)	{		U2GpuProgram* pProgramItr = U2GpuProgram::GetHead();	bool bFound = false;	while(pProgramItr)	{		if(pProgramItr->GetName() == szShadername)		{			m_spProgram = pProgramItr;			bFound = true;			break;		}				pProgramItr = pProgramItr->GetNext();	}	if(!m_spProgram)	{		m_spProgram =U2VertexProgram::Load(szShadername);			}	if(m_spProgram)	{		FILE_LOG(logDEBUG) << _T("Vertex Shader ") << szShadername.Str() << _T(" loaded");		OnLoadProgram();	}}

inline bool Store::shouldIgnoreRequest(){    time_t currentTime = time(0);        resetTransactionMonitorCounterIfRequired(currentTime);        double percentFailed = 0;    int recentTransactionsCount = NDBMessageProcessor::_noRecentTransactions;    if(recentTransactionsCount > 0)        percentFailed = NDBMessageProcessor::_noRecentFailedTransactions/recentTransactionsCount;        if(percentFailed > 0)    {        int randVal = rand()%100;                //ignore request, TODO: user should get a reponse that it's a temp error and should try again.        if(randVal < (int)percentFailed)        {            FILE_LOG(logINFO)<<"Ignoring request because of failing transactions";            return true;        }    }    return false;}

  void KernelModel::setKernel (const vectord &thetav, 			      const vectord &stheta,			      std::string k_name, 			      size_t dim)  {    KernelFactory mKFactory;    mKernel.reset(mKFactory.create(k_name, dim));    if ((thetav.size() == 1) && (stheta.size() == 1) && (mKernel->nHyperParameters() != 1))      {	// We assume isotropic prior, so we replicate the vectors for all dimensions	size_t n = mKernel->nHyperParameters();	FILE_LOG(logINFO) << "Expected " << n << " hyperparameters."			  << " Replicating parameters and prior.";	vectord newthetav = svectord(n,thetav(0));	vectord newstheta = svectord(n,stheta(0));	setKernelPrior(newthetav,newstheta);	mKernel->setHyperParameters(newthetav);      }    else      {	setKernelPrior(thetav,stheta);	mKernel->setHyperParameters(thetav);      }  }

double TriConstraint::slack(const double ux, const double vx, const double wx) const {    const double lhs = wx;    const double rhs = ux+p*(vx-ux)+g;    FILE_LOG(logDEBUG1)<<"  TriConstraint::slack("<<ux<<","<<vx<<","<<wx<<"):leftOf="<<leftOf<<",lhs="<<lhs<<",rhs="<<rhs;    return leftOf ? rhs - lhs                  : lhs - rhs;}