Esempio n. 1
0
void CMaquetteImpl::send(CPacketToSend& packet, bool wait /*= false*/)
{
	const data_t data = packet.encode();
	LOG4CPLUS_DEBUG(logger, "Sending " << CPacket::Type::toString(data[0]) << ": " << data.size() << " byte\n" << CUtils::dump(data).c_str());

	// Send message to the server
	// See https://casablanca.codeplex.com/wikipage?title=Web%20Socket&referringTitle=Documentation
	auto buf = std::make_shared<producer_consumer_buffer<byte>>();
	auto task = buf->putn_nocopy(data.data(), data.size())
		.then([=](size_t size) {
			websocket_outgoing_message msg;
			msg.set_binary_message(buf->create_istream(), size);
			pplx::task<void>task = m_client->send(msg);
			task.then([](pplx::task<void> t) {
				try {
					t.get();
				} catch(const websocket_exception& ex) {
					LOG4CPLUS_ERROR(logger, "websocket_callback_client::send() failed: " << ex.what());
				}
			});
			return task;
		});
		
	if(wait) task.wait();
	if(packet.type() != CPacket::Type::PINGREQ) {
		m_keepAliveTimer.restart();
	}
}
Esempio n. 2
0
 void CTCPProfile::Compress(const data_t &data, data_t &output) {
     size_t outputInSize = output.size();
     const iphdr* ip = reinterpret_cast<const iphdr*>(&data[0]);
     const tcphdr* tcp = reinterpret_cast<const tcphdr*>(ip+ip->ihl*4);
     
     UpdateIpIdOffset(ip);
     
     if (IR_State == state)
     {
         CreateIR(ip, tcp, output);
     }
     else
     {
         CreateCO(ip, tcp, output);
     }
     
     UpdateIpInformation(ip);
     
     AdvanceState(false, false);
     increaseMsn();
     // Append payload
     // TODO, handle TCP options
     output.insert(output.end(), data.begin() + sizeof(iphdr) + sizeof(tcphdr), data.end());
     
     ++numberOfPacketsSent;
     dataSizeCompressed += output.size() - outputInSize;
     dataSizeUncompressed += data.size();
     
 }
Esempio n. 3
0
void random_forest_p(const data_t& train, const vec_data_t& test, preds_t& train_preds, vec_preds_t& test_preds, args_t& args) {
  int trees = args.trees;
  int numthreads=args.processors, i, x, t;
  int fk = args.kfeatures;
  if (numthreads > trees)
    numthreads = trees;
  trees = (trees / numthreads) * numthreads;

  int trees_per_thread = trees / numthreads;  
  thread** threads = new thread*[numthreads];

  vector< vec_preds_t > seg;
  vector< preds_t > train_seg;
  for (i=0; i < numthreads; i++) {
    vec_preds_t p;
    init_pred_vec(test, p);
    seg.push_back(p);

    preds_t tp;
    init_pred(train, tp);
    train_seg.push_back(tp);
  }
 
  for (i=0;i<numthreads;i++)
    threads[i] = new thread(bind(multiple_forest, trees_per_thread, cref(train), cref(test), ref(train_seg[i]), ref(seg[i]), ref(args)));
  
  for (i=0;i<numthreads;i++){
    threads[i]->join();
    delete threads[i];
  }
  fprintf(stderr, "done threading\n");
  delete[] threads;

  // congregate results of the threads
  for (i = 0; i < numthreads; i++)
    for (t = 0; t < test.size(); t++)
      for (int j = 0; j < test[t].size(); j++)
	test_preds[t][j] += seg[i][t][j];

  for (i = 0; i < numthreads; i++)
      for (int j = 0; j < train.size(); j++)
	train_preds[j] += train_seg[i][j];

  // average results of the trees
  for (i = 0; i < test.size(); i++)
    for (int j = 0; j < test[i].size(); j++)
      test_preds[i][j] /= trees;

  for (int j = 0; j < train.size(); j++)
    train_preds[j] /= trees;

  // write results to file
  for (i = 0; i < test.size(); i++) {
    tuple::write_to_file(test_preds[i], test[i], args.test_outs[i]);
  }
}
Esempio n. 4
0
    secure_session_t(const data_t& id, const data_t& priv_key, secure_session_callback_interface_t* callbacks):
      _session(NULL),
      _res(0){
      _callback.get_public_key_for_id=themispp::get_public_key_for_id_callback;
      _callback.send_data=themispp::send_callback;
      _callback.receive_data=themispp::receive_callback;
      _callback.state_changed=NULL;
      _callback.user_data=callbacks;
      _session=secure_session_create(&id[0], id.size(), &priv_key[0], priv_key.size(), &_callback);
      if(!_session)
	throw themispp::exception_t("Secure Session failde creating");
    }
Esempio n. 5
0
File: main.cpp Progetto: CCJY/coliru
    static bool range(data_t const& args, data_t& into) {
        // unpack arguments
        if (args.size() != 2)
            return false;
        auto f = args[0], l = args[1];

        if (l>f)
            into.reserve(1 + l - f + into.size());
        for(; f<=l; ++f)
            into.push_back(f); // to optimize

        return true;
    }
Esempio n. 6
0
double variation(data_t &dataset, size_t split){
	data_t::iterator i;
	double mean = 0;
	double variation = 0;
	for (i = dataset.begin(); i != dataset.end(); i++){
		mean += i->at(split);
	}
	mean /= dataset.size();
	for (i = dataset.begin(); i != dataset.end(); i++){
		variation += pow(i->at(split) - mean, 2.0);
	}
	variation /= dataset.size();
	return variation;
}
Esempio n. 7
0
File: main.cpp Progetto: CCJY/coliru
    static bool fibonacci(data_t const& args, data_t& into) {
        // unpack arguments
        if (args.size() != 2)
            return false;
        auto f = args[0], l = args[1];

        // iterate
        uint64_t gen0 = 0, gen1 = 1, next = gen0 + gen1;
        for(auto i = 0u; i <= l; ++i)
        {
            std::cout << "fibonacci(" << f << ", " << l << ") at i == " << i << ", next: " << next << "\n";
            switch(i) {
            case 0:
                if (i>=f) into.push_back(gen0);
                break;
            case 1:
                if (i>=f) into.push_back(gen1);
                break;
            default:
            {
                next = gen0 + gen1;
                if (i>=f) into.push_back(next);
                gen0 = gen1;
                gen1 = next;
                break;
            }
            }
        }

        std::cout << "fibonacci(" << f << ", " << l << ") result: " << karma::format_delimited(karma::auto_, ';', into) << "\n";
        // done
        return true;
    }
Esempio n. 8
0
    string TH_0x20::makeStringFromData(const data_t& data, const options_t& options)
    {
        (void)options;

        if (data.size() != dataByteCount)
        {
            throw invalid_argument("Empty data array. Needs to contain " + to_string(dataByteCount) + " bytes");
        }

        string coeff = TH_0x00::makeStringFromData(data);

        string str = ((coeff != "0") ? (coeff + "*π") : "");

        // Improve final display
        str = regex_replace(str, regex("\\+1\\*"), "+");  str = regex_replace(str, regex("\\(1\\*"),  "(");
        str = regex_replace(str, regex("-1\\*"),   "-");  str = regex_replace(str, regex("\\(-1\\*"), "(-");
        str = regex_replace(str, regex("\\+-"),    "-");

        // Shouldn't happen - I don't believe the calc generate such files.
        if (str == "")
        {
            str = "0";
        }

        return str;
    }
Esempio n. 9
0
	file_offset_t bin_index_t::file_node::append_data(const data_t& res)
	{
		open_data_file();
		file_offset_t ret=fd->append(res);
		data_size=ret+res.size();
		return ret;
	}
Esempio n. 10
0
    string TH_0x01::makeStringFromData(const data_t& data, const options_t& options)
    {
        (void)options;

        string str;

        size_t byteCount = data.size();
        size_t numCount = (size_t) ((data[0] & 0xFF) + ((data[1] << 8) & 0xFF00));
        if (byteCount < 2+TH_0x00::dataByteCount || ((byteCount - 2) % TH_0x00::dataByteCount != 0)
            || (numCount != (size_t)((byteCount - 2) / TH_0x00::dataByteCount)) || numCount > 999)
        {
            std::cerr << "Invalid data array. Needs to contain 2+" + to_string(TH_0x00::dataByteCount) + "*n bytes" << endl;
            return "";
        }

        str = "{";

        for (size_t i = 2, num = 0; i < byteCount; i += TH_0x00::dataByteCount, num++)
        {
            str += TH_0x00::makeStringFromData(data_t(data.begin()+i, data.begin()+i+TH_0x00::dataByteCount));
            if (num < numCount - 1) // not last num
            {
                str += ',';
            }
        }

        str += "}";

        return str;
    }
Esempio n. 11
0
    std::string STH_ExactFractionPi::makeStringFromData(const data_t& data, const options_t& options)
    {
        if (data.size() != 9)
        {
            throw std::invalid_argument("Invalid data array. Needs to contain 9 bytes");
        }

        return dec2frac(stod(STH_FP::makeStringFromData(data, options)), "π");
    }
	void bin2points(const data_t& bin,points_t& pts)
	{
		if((bin.size()%2)!=0)
			throw std::runtime_error("bin2points(): (bin.size()%2)!=0");

		pts.resize(bin.size()/2);

		for(unsigned i=0;i<pts.size();i++)
		{
			point& p=pts[i];

			char x=*reinterpret_cast<const unsigned char*>(&bin[i*2]);
			char y=*reinterpret_cast<const unsigned char*>(&bin[i*2+1]);

			p.x=x;
			p.y=y;
		}
	}
	void bin2points(const data_t& bin,steps_t& pts)
	{
		if((bin.size()%3)!=0)
			throw std::runtime_error("bin2points(): (bin.size()%3)!=0");

		pts.resize(bin.size()/3);

		for(unsigned i=0;i<pts.size();i++)
		{
			step_t& p=pts[i];

			char x=*reinterpret_cast<const unsigned char*>(&bin[i*3]);
			char y=*reinterpret_cast<const unsigned char*>(&bin[i*3+1]);

			p.x=x;
			p.y=y;
			p.step=(Step)bin[i*3+2];
		}
	}
Esempio n. 14
0
void construct(point &root, data_t dataset){
	if (dataset.size() == 0)
		return;
	root = new point_t();
	vector< double > buff;
	for (size_t i = 0; i < dataset.at(0).size(); i++){
		buff.push_back(variation(dataset, i));
	}
	size_t split = 0;
	double min;
	for (size_t i = 0; i < buff.size(); i++){
		if (i == 0){
			min = buff.at(i);
		}
		else{
			if (min < buff.at(i)){
				min = buff.at(i);
				split = i;
			}
		}
	}
	sort(dataset.begin(), dataset.end(), [split](vec_t a, vec_t b){ return a.at(split) < b.at(split); });
	size_t middle = dataset.size() / 2;
	root->split = split;
	for (size_t i = 0; i < dataset.at(middle).size(); i++){
		root->node.push_back(dataset.at(middle).at(i));
	}
	root->dim = root->node.size();
	data_t lDataset, rDataset;
	for (size_t i = 0; i < middle; i++){
		lDataset.push_back(dataset.at(i));
	}
	for (size_t i = middle + 1; i < dataset.size(); i++){
		rDataset.push_back(dataset.at(i));
	}
	construct(root->left, lDataset);
	construct(root->right, rDataset);
	if (root->left)
		root->left->parent = root;
	if (root->right)
		root->right->parent = root;
	return;
}
Esempio n. 15
0
	bool bin_index_t::file_node::set(const data_t& key,const data_t& val)
	{
		validate_key_len(key);
		open_index_file();

		if(!root_page)
		{
			root_page=create_page();
			append_page(*root_page);
			save_index_data(0,root_page->page_offset);
			add_page(root_page);
		}
		
		index_t it;
		align_key(key,it);

		if(get_item(it))
		{
			index_t old_i=it;

			if(it.data_len>=val.size())save_data(it.data_offset,val);
			else it.data_offset=append_data(val);
			it.data_len=val.size();

			if(old_i.data_offset==it.data_offset&&
				old_i.data_len==it.data_len)
				return false;

			update_page(it);
			return false;
		}

		index_t v;
		v.key=key;
		align_key(key,v);
		v.data_len=val.size();
		v.data_offset=append_data(val);

		add_item(v);

		return true;
	}
Esempio n. 16
0
    void CTCPProfile::CreateIR(const ROHC::iphdr *ip, const ROHC::tcphdr *tcp, data_t &output) {
        size_t headerStartIdx = output.size();
        
        if (!largeCID && cid)
        {
            output.push_back(CreateShortCID(cid));
        }
        
        output.push_back(IRv2Packet);
        
        if (largeCID)
        {
            SDVLEncode(back_inserter(output), cid);
        }
        
        output.push_back(static_cast<uint8_t>(ProfileID()));
        
        size_t crcPos = output.size();
        
        // Add zero crc for now
        output.push_back(0);
        
        create_ipv4_static(ip, output);
        
        create_tcp_static(tcp, output);
        
        create_ipv4_regular_innermost_dynamic(ip, output);
        
        //create_tcp_dynamic(msn, reorder_ratio, udp, output);
        
        // Calculate CRC
        uint8_t crc = CRC8(output.begin() + headerStartIdx, output.end());
        output[crcPos] = crc;
        
		IncreasePacketCount(PT_IR);
        
        ++numberOfIRPacketsSent;
        ++numberOfIRPacketsSinceReset;
    }
Esempio n. 17
0
    string TH_0x02::makeStringFromData(const data_t& data, const options_t& options)
    {
        (void)options;

        size_t byteCount = data.size();
        size_t colCount = data[0];
        size_t rowCount = data[1];

        if (data.size() < 2+TH_0x00::dataByteCount || colCount < 1 || rowCount < 1 || colCount > 255 || rowCount > 255
            || ((byteCount - 2) % TH_0x00::dataByteCount != 0) || (colCount*rowCount != (byteCount - 2) / TH_0x00::dataByteCount))
        {
            std::cerr << "Invalid data array. Needs to contain 1+1+" << TH_0x00::dataByteCount << "*n bytes" << std::endl;
            return "";
        }

        string str = "[";

        for (uint i = 2, num = 0; i < byteCount; i += TH_0x00::dataByteCount, num++)
        {
            if (num % colCount == 0) // first column
            {
                str += "[";
            }
            str += TH_0x00::makeStringFromData(data_t(data.begin()+i, data.begin()+i+TH_0x00::dataByteCount));
            if (num % colCount < colCount - 1) // not last column
            {
                str += ",";
            } else {
                str += "]";
            }
        }

        str += "]";

        // TODO: prettified option
        
        return str;
    }
int RansacFitLine::GetInliers(const data_t& data,
                              const std::vector<model_t>& models,
                              std::vector<int>* inliers) const {
  for (size_t i = 0; i < data.size() / 2; i++) {
    double distance = fabs(data[2*i] * models[0][0] +
                           data[2*i+1] * models[0][1] -
                           models[0][2]);
    if (distance <= threshold_) {
      inliers->push_back(i);
    }
  }
  
  return 0;
}
Esempio n. 19
0
/** Sets the filter. 
 * The length of the impulse response is arbitrary. It automatically
 * performs zero padding if necessary and creates the required number of 
 * partitions. It is not very efficient since it calls 
 * \b Convolver::prepare_impulse_response(). It is provided for convenience.
 * If you have the filter's transfer function in halfcomplex format use
 * \b Convolver::set_filter_f() instead. 
 * @param filter impulse response of the filter
 */
void Convolver::set_filter_t(const data_t& filter)
{

	if (filter.empty())
	{
		WARNING("You are trying to use an empty filter.");
		return;
	}

	data_t buffer;

	// TODO: It would be more efficient to use _fft_plan and _fft_buffer etc.
	prepare_impulse_response(buffer, &filter[0], filter.size(), _frame_size);

	set_filter_f(buffer);
}
Esempio n. 20
0
    string TH_0x1B::makeStringFromData(const data_t& data, const options_t& options)
    {
        (void)options;

        if (data.size() != dataByteCount)
        {
            throw invalid_argument("Empty data array. Needs to contain " + to_string(dataByteCount) + " bytes");
        }

        string coeffR = TH_0x00::makeStringFromData(data_t(data.begin(), data.begin() + TH_0x00::dataByteCount));
        string coeffI = TH_0x00::makeStringFromData(data_t(data.begin() + TH_0x00::dataByteCount, data.begin() + 2 * TH_0x00::dataByteCount));

        string str = dec2frac(atof(coeffR.c_str())) + "+" + dec2frac(atof(coeffI.c_str())) + "i";
        str = regex_replace(str, regex("\\+-"), "-");

        return str;
    }
Esempio n. 21
0
 secure_comparator_t(const data_t& shared_secret)
     : comparator_(NULL)
 {
     if (shared_secret.empty()) {
         throw themispp::exception_t("Secure Comparator must have non-empty shared secret");
     }
     res_.reserve(512);
     comparator_ = secure_comparator_create();
     if (!comparator_) {
         throw themispp::exception_t("Secure Comparator construction failed");
     }
     themis_status_t status = secure_comparator_append_secret(comparator_,
                                                              &shared_secret[0],
                                                              shared_secret.size());
     if (THEMIS_SUCCESS != status) {
         throw themispp::exception_t("Secure Comparator failed to append secret", status);
     }
 }
Esempio n. 22
0
    string TH_0x00::makeStringFromData(const data_t& data, const options_t& options)
    {
        (void)options;

        if (data.size() != dataByteCount)
        {
            throw invalid_argument("Empty data array. Needs to contain " + to_string(dataByteCount) + " bytes");
        }

        uint flags      = data[0];
        bool isNegative = (flags >> 7 == 1);
//      bool isSeqInit  = (flags  & 1 == 1); // if true, "used for initial sequence values"
        int exponent    = data[1] - 0x80;
        string number   = "";
        for (uint i = 2; i < TH_0x00::dataByteCount; i++)
        {
            number += (data[i] < 0x10 ? "0" : "") + dechex(data[i]); // zero left pad
        }
        number = number.substr(0, 1) + "." + number.substr(1);

        char buf[35] = {0};
        sprintf(buf, "%.*f", DECIMAL_DIG, pow(10, exponent) * atof(number.c_str()));
        string str(buf);

        // Cleanup
        if (str.length() > 12)
        {
            str.erase(str.begin() + 12, str.end());
        }
        if (str.find('.') != std::string::npos)
        {
            while (str.back() == '0') str.pop_back();
        }
        if (str.back() == '.')
        {
            str.pop_back();
        }

        str = (isNegative ? "-" : "") + str;

        return str;
    }
//min-max splits based on impurity measure
bool impurity_splitW_noMiss(data_t data,  int& f_split, double& v_split,  double imp, boost::numeric::ublas::vector<int>& c_total,args_t& myargs, double (*impurityHandle)(int, boost::numeric::ublas::vector<int>&,double)) {
	int NF=myargs.features;
	int num_c=myargs.num_c;
	double alpha=myargs.alpha;
	f_split = -1;
	double min = MY_DBL_MAX, cf;
	int n = data.size(), i,j ;
	double imp_l=0.0, imp_r=0.0, imp_m=0.0, imp_max=0.0; //impurity on the left

	double mind;
	double v_split_d;
	for (int f = 1; f < NF; f++) { //for each feature
		cf=myargs.Costs[f];
		sort(data.begin(), data.end(), boost::bind(mysortf, _1,_2, f));
		boost::numeric::ublas::vector<int> c_l(num_c,0); //number of examples in each class on the left
		boost::numeric::ublas::vector<int> c_r(c_total); //number of examples in each class on the right
		
		mind = MY_DBL_MAX;
		//assume no missing data
		for( i=0;i<n-1;i++){
			c_l[data[i]->label]++;
			c_r[data[i]->label]--;
			// do not consider splitting here if data is the same as next
			if (data[i]->features[f] == data[i+1]->features[f])
				continue;
			imp_l=(*impurityHandle)(num_c, c_l, alpha);
			imp_r=(*impurityHandle)(num_c, c_r, alpha);
			imp_max=(imp_l < imp_r) ? imp_r: imp_l;
			if(imp_max<mind){
				mind=imp_max;
				v_split_d = (data[i]->features[f] + data[i+1]->features[f])/2;
			}
		}

		if ((imp-mind>0.0000001) && (cf/(imp-mind) < min)) {
			min = cf/(imp-mind);
			f_split = f;
			v_split = v_split_d;
		}
	}	
	return min != MY_DBL_MAX;
}
Esempio n. 24
0
        std::string encode(const data_t& data) const {
            auto end = reinterpret_cast<const uint8_t*>(&*data.end());
            uint8_t tmp[base_t::digits_per_unit];
            char out[base_t::digits_per_unit];

            std::string text;
            text.reserve(this->estimate(data.size()));
            auto in = reinterpret_cast<const uint8_t*>(data.data());
            size_t n = 0;
            while (in < end) {
                n = this->stretch(in, tmp, end);
                for (size_t i = 0; i < n; ++i) {
                    out[i] = this->digit(tmp[i]);
                }
                text.append(out, n);
            }
            if (this->padding and n != 0 and n != sizeof(out)) {
                text.append(sizeof(out) - n, '=');
            }
            return text;
        }
Esempio n. 25
0
    void send(const data_t& data){
      ssize_t send_size=secure_session_send(_session, &data[0], data.size());
      if(send_size<=0)
	throw themispp::exception_t("Secure Session failed sending");
    }
Esempio n. 26
0
bool dt_node::entropy_split(data_t data, vector<int> dataCount, vector<int> invertIdx, int NF, int& f_split, double& v_split, int K, bool par) {
  f_split = -1;
  double min = MY_DBL_MAX;
  int n = data.size(), i;
  
  vector<bool> skip;

  //min E(i=1..k) pi * log(1/pi)
  
  for (i = 0; i <= NF; i++)
    skip.push_back( (K > 0) ? true : false);

  for (i = 0; i < K; i++) {
    int f;
    do
      f = rand() % (NF-2) + 1;
    while (!skip[f]);
    skip[f] = false;
  }


  //if (K <= 0)
  //return find_split_p(data, NF, f_split, v_split, skip);

  vector<int> location(n, -1);
  for (int f = 1; f < NF; f++) {
	if (skip[f]) continue;
	sort_data_by_feature(location, dataCount, invertIdx, f);
    //sort_data_by_feature(data,f);

    //if (skip[f]) continue;

    /*
 vector< pair<tuple*, int> > tk;
  int z;

  for (z = 0; z < data.size(); z++)
  tk.push_back( pair<tuple*,int>(data[z], f) );
  sort(tk.begin(), tk.end(), mysortpred2);


  for (z = 0; z < data.size(); z++)
  data[z] = tk[z].first;
    */


  int num_c = 7;
  vector<double> c_miss, c_left, c_right;
  //vector<double> p_miss, p_left, p_right;
  //vector<int> freq;
  //int n_left = 0, n_right = 0;
  for (i=0;i<num_c;i++) {
	c_miss.push_back(0.0);
//	p_miss.push_back(0.0);
    c_left.push_back(0.0);
    c_right.push_back(0.0);
//    p_left.push_back(0.0);
//    p_right.push_back(0.0);
//    freq.push_back(0);
  }



    // get impurity (entropy) for missing data
    double M = 0.0, L, R, W_miss = 0.0, W_left = 0.0, W_right = 0.0;
    int missing = 0;
	int loc = location[missing];
    while (data[loc]->features[f] == UNKNOWN && missing < n-1) {
	c_miss[(int)data[loc]->target] += data[loc]->weight;
	W_miss += data[loc]->weight;
        missing++;
	loc = location[missing];
    }

    if (missing == n-1) // all data is missing
      continue;

    int nn = n - missing; // number of data points that arent missing
    // entropy
    // put all data into right side R
    int start = missing;
    for (i = start; i < n; i++) {
	loc = location[i];
      	c_right[(int)data[loc]->target]+=data[loc]->weight;
      	W_right+=data[loc]->weight;
    }
	if (W_right){
    		for (i = 0; i < num_c; i++) {
      			if (c_right[i])
				R += c_right[i]/W_right * log(W_right / c_right[i]);
    		}
	}

    	if (missing && W_miss) {
                for (i = 0; i < num_c; i ++){
                        if (c_miss[i])
                                M += c_miss[i]/W_miss * log(W_miss/c_miss[i]);
                }
    	}
    	L = 0.0;

    // for every i
    // put yi into left side, remove it from the right side, and calculate squared lost
    for (i = start; i < n-1; i++) {
      int j = i - missing; 
      int yn = (int)data[loc]->target;

	W_right -= data[loc]->weight;
	W_left += data[loc]->weight;
      //n_right--;
      //n_left++;
	c_left[yn] += data[loc]->weight;
	c_right[yn] -= data[loc]->weight;
      //c_left[yn]++;
      //c_right[yn]--;

      //p_left[yn] += 1.0 / freq[yn];
      //p_right[yn] -= 1.0 / freq[yn];

      // do not consider splitting here if data is the same as next
      if (data[location[i]]->features[f] == data[location[i+1]]->features[f])
	continue;

      L = 0.0;
      int k;
      for (k = 0; k < num_c; k++) {
      	if (c_left[k])
	  L +=  c_left[k]/W_left * log(W_left / c_left[k]); 
      }
      R = 0.0;
      for (k = 0; k < num_c; k++) {
	if (c_right[k])
	  R += c_right[k]/W_right * log(W_right / c_right[k]);   
      }
      double ssum = W_left+W_right+W_miss;
      double I = W_left/ssum * L +  W_right/ssum * R + W_miss/ssum * M;
      //I = 1.0*n_left/n * 

      /*
      L = 0.0, R = 0.0;
      for (i = 0; i < num_c; i++)
	L += p_left;
      */

      if (I < min) {
	min = I;
	f_split = f;
	v_split = (data[location[i]]->features[f] + data[location[i+1]]->features[f])/2;
      }
    }
  }

  return min != MY_DBL_MAX;
}
Esempio n. 27
0
	void bin_index_t::inode::validate_key_len(const data_t& key) const
	{
		if(key.size()!=key_len)throw std::runtime_error("invalid key length");
	}
Esempio n. 28
0
 int getSize() const
 {
   return m_verts.size();
 }
Esempio n. 29
0
 bool io::uncompress_gzip(const data_t& istream, data_t& data)
 {
         stream_t stream(istream.data(), istream.size());
         return io_uncompress_gzip(stream, stream.size(), data);
 }