C++ CharacterVector::end方法代码示例

    CharacterVector get_uniques( const CharacterVector& left, const CharacterVector& right){
        int nleft = left.size(), nright = right.size() ;
        int n = nleft + nright ;

        CharacterVector big = no_init(n) ;
        CharacterVector::iterator it = big.begin() ;
        std::copy( left.begin(), left.end(), it ) ;
        std::copy( right.begin(), right.end(), it + nleft ) ;
        return Language( "unique", big ).fast_eval() ;
    }

void count_clusters(std::map<std::string, int> &counts,
                    CharacterVector these_clusters,
                    CharacterVector cluster_names) {

    int n = these_clusters.size();

    for(int i=0; i < n; i++) {
        counts[as<std::string>(these_clusters[i])]++;
    }

    //print_cluster_counts(counts);

    // add clusters with no counts
    CharacterVector::iterator it;
    for(it = cluster_names.begin(); it != cluster_names.end(); ++it) {

        // if this name not in map, make an entry and set it to zero
        if(counts.find(as<std::string>(*it)) == counts.end()) {
            counts[as<std::string>(*it)] = 0;
        }

    }

    //print_cluster_counts(counts);

    return;
}

HttpResponse* listToResponse(HttpRequest* pRequest,
                             const Rcpp::List& response) {
  using namespace Rcpp;

  if (response.isNULL() || response.size() == 0)
    return NULL;

  CharacterVector names = response.names();

  int status = Rcpp::as<int>(response["status"]);
  std::string statusDesc = getStatusDescription(status);

  List responseHeaders = response["headers"];

  // Self-frees when response is written
  DataSource* pDataSource = NULL;

  // The response can either contain:
  // - bodyFile: String value that names the file that should be streamed
  // - body: Character vector (which is charToRaw-ed) or raw vector, or NULL
    if (std::find(names.begin(), names.end(), "bodyFile") != names.end()) {
    FileDataSource* pFDS = new FileDataSource();
    pFDS->initialize(Rcpp::as<std::string>(response["bodyFile"]),
        Rcpp::as<bool>(response["bodyFileOwned"]));
    pDataSource = pFDS;
  }
  else if (Rf_isString(response["body"])) {
    RawVector responseBytes = Function("charToRaw")(response["body"]);
    pDataSource = new RawVectorDataSource(responseBytes);
  }
  else {
    RawVector responseBytes = response["body"];
    pDataSource = new RawVectorDataSource(responseBytes);
  }

  HttpResponse* pResp = new HttpResponse(pRequest, status, statusDesc,
                                         pDataSource);
  CharacterVector headerNames = responseHeaders.names();
  for (R_len_t i = 0; i < responseHeaders.size(); i++) {
    pResp->addHeader(
      std::string((char*)headerNames[i], headerNames[i].size()),
      Rcpp::as<std::string>(responseHeaders[i]));
  }

  return pResp;
}

// [[Rcpp::export]]
List ctmcFit(List data, bool byrow=true, String name="", double confidencelevel = 0.95)
{
  CharacterVector stateData(as<CharacterVector>(data[0]).size());
  for(int i = 0; i < as<CharacterVector>(data[0]).size(); i++)
    stateData[i] = as<CharacterVector>(data[0])[i];
  NumericVector transData = data[1];
  CharacterVector sortedStates = unique(as<CharacterVector>(data[0])).sort();
  NumericVector stateCount(sortedStates.size());
  NumericVector stateSojournTime(sortedStates.size());
  
  List dtmcData = markovchainFit(stateData, "mle", byrow, 10, 0, name, false, confidencelevel);
  
  for(int i = 0; i < stateData.size() - 1; i++){
    int idx = std::find(sortedStates.begin(), sortedStates.end(), stateData[i]) - sortedStates.begin();
    stateCount[idx]++;
    stateSojournTime[idx] += transData[i+1] - transData[i];
  }
  
  S4 dtmcEst = dtmcData["estimate"];
  NumericMatrix gen = dtmcEst.slot("transitionMatrix");
  
  for(int i = 0; i < gen.nrow(); i++){
    for(int j = 0; j < gen.ncol(); j++){
      if(stateCount[i] > 0)
        gen(i, j) *= stateCount[i] / stateSojournTime[i];
    }
    if(stateCount[i] > 0)
      gen(i, i) = - stateCount[i] / stateSojournTime[i];
    else  
      gen(i, i) = -1;
  }
  
  double zscore = stats::qnorm_0(confidencelevel, 1.0, 0.0);
  NumericVector lowerConfVecLambda(sortedStates.size()), upperConfVecLambda(sortedStates.size());
  
  for(int i = 0; i < sortedStates.size(); i++){
    if(stateCount[i] > 0){
      lowerConfVecLambda(i) = std::max(0., stateCount[i] / stateSojournTime[i] * (1 - zscore / sqrt(stateCount[i])));
      upperConfVecLambda(i) = std::min(1., stateCount[i] / stateSojournTime[i] * (1 + zscore / sqrt(stateCount[i])));
    }
    else{
      lowerConfVecLambda(i) = 1;
      upperConfVecLambda(i) = 1;
    }
  }
  
  S4 outCtmc("ctmc");
  outCtmc.slot("states") = sortedStates;
  outCtmc.slot("generator") = gen;
  outCtmc.slot("name") = name;
  
  return List::create(_["estimate"] = outCtmc,
                      _["errors"] = List::create(_["dtmcConfidenceInterval"] = dtmcData["confidenceInterval"],
                      _["lambdaConfidenceInterval"] = List::create(_["lowerEndpointVector"] = lowerConfVecLambda,
                      _["upperEndpointVector"] = upperConfVecLambda)));
}

// [[Rcpp::export]]
std::string character_iterator1( CharacterVector letters ){
    std::string res ;
    CharacterVector::iterator first = letters.begin() ;
    CharacterVector::iterator last = letters.end() ;
    while( first != last ){
        res += *first ;
    	++first ;
    }
    return res ;
}

void check_dataframes_names_consistency(const List& x) {
  CharacterVector ref = get_element_names(x, 0);
  int equi_named = 1;

  for (int i = 0; i < x.size(); ++i) {
    CharacterVector names = get_element_names(x, i);
    equi_named *= std::equal(ref.begin(), ref.end(), names.begin());
  }

  if (!equi_named)
    stop("data frames do not have consistent names");
}

void inner_find(CharacterVector& y,IDFmap& m,unsigned int dis){
  for(CharacterVector::iterator it = y.begin();it!=y.end();it++){
    string tmp = as<string>(*it);
    IDFmap::iterator m_it = m.find(tmp);
    if(m_it==m.end()){
      m[tmp].first=dis;
      m[tmp].second=1;
    }else{
      if((*m_it).second.first != dis){
        (*m_it).second.first = dis;
        (*m_it).second.second =(*m_it).second.second+1;
      }
    }
  }
}

// [[Rcpp::export]]
void write_lines_(const CharacterVector &lines, const std::string &path, const std::string& na, bool append = false) {

  std::ofstream output(path.c_str(), append ? std::ofstream::app : std::ofstream::trunc);
  if (output.fail()) {
    stop("Failed to open '%s'.", path);
  }
  for (CharacterVector::const_iterator i = lines.begin(); i != lines.end(); ++i) {

    if (CharacterVector::is_na(*i)) {
      output << na << '\n';
    } else {
      output << Rf_translateCharUTF8(*i) << '\n';
    }
  }

  return;
}

vector<mihandle_t> open_minc2_volumes(CharacterVector filenames){
  
  vector<mihandle_t> volumes;
  mihandle_t current_handle;
  CharacterVector::iterator file_iterator;
  vector<mihandle_t>::iterator volume_iterator;
  
  for(file_iterator = filenames.begin();
      file_iterator != filenames.end();
      ++file_iterator){
    try {
      current_handle = open_minc2_volume(wrap(*file_iterator));
    } catch(...){
      for(volume_iterator = volumes.begin(); volume_iterator != volumes.end(); ++volume_iterator){
        miclose_volume(*volume_iterator);
      }
      throw;
    }
    
    volumes.push_back(current_handle);
  }
  
  return(volumes);
}

// [[Rcpp::export]]
int character_find_(CharacterVector y){
	CharacterVector::iterator it = std::find( y.begin(), y.end(), "foo" ) ;
	return std::distance( y.begin(), it );
}

// [[Rcpp::export]]
CharacterVector character_reverse( CharacterVector y ){
    std::reverse( y.begin(), y.end() ) ;
    return y ;
}

// [[Rcpp::export]]
std::string character_iterator2( CharacterVector letters ){
    std::string res(std::accumulate(letters.begin(), letters.end(), std::string()));
    return res ;
}

// Checks for unknown variables in expression
// [[Rcpp::export]]
void check_for_unknown_vars_impl(List model, SEXP x) {
  std::stack<SEXP> stack;
  stack.push(x);
  List model_vars = model["variables"];
  std::string error_msg =
      "The expression contains a variable that is not part of the model.";
  while (!stack.empty()) {
    SEXP local_obj = stack.top();
    stack.pop();
    int local_obj_type = TYPEOF(local_obj);
    bool is_call = local_obj_type == LANGSXP;
    if (local_obj_type == SYMSXP) {
      try {
        CharacterVector var = local_obj;
        std::string var_name = as<std::string>(var[0]);
        List model_var = model_vars[var_name];
        int arity = model_var["arity"];
        if (arity > 0) {
          throw std::invalid_argument("");
        }
      } catch (...) {
        ::Rf_error(error_msg.c_str());
      }
    }
    if (is_call) {
      Language ast(local_obj);
      int n_size = ast.size();
      if (n_size >= 3) {
        CharacterVector op(ast[0]);
        std::string op_string = as<std::string>(op);
        if (op_string == "[" && TYPEOF(ast[1]) == SYMSXP) {
          CharacterVector var = ast[1];
          std::string var_name = as<std::string>(var[0]);
          try {
            List var = model_vars[var_name];
            CharacterVector instances = var["instances"];

            // build search key
            std::ostringstream str;
            for (int i = 2; i < n_size; i++) {
              CharacterVector idx = ast[i];
              str << as<std::string>(idx);
              if (i != n_size - 1) {
                str << "_";
              }
            }
            if (n_size > 1) {
              CharacterVector search_key = str.str();
              bool found = std::find(instances.begin(), instances.end(),
                                     search_key[0]) != instances.end();
              if (!found) {
                throw std::invalid_argument("");
              }
            }
          } catch (...) {
            ::Rf_error(error_msg.c_str());
          }
          continue;
        }
      }
      for (int i = 1; i < ast.size(); i++) {
        stack.push(ast[i].get());
      }
    }
  }
}

// [[Rcpp::export]]
List is_valid_nt_fasta_format(CharacterVector file_lines)
{
	long header_count = 0;
	long line_count = 0;
	for(CharacterVector::iterator it = file_lines.begin(); it != file_lines.end(); ++it)
	{	
		line_count++;
		long count = 0;
		for (int i = 0; i < (*it).size(); ++i)
		{
			char x = (*it)[i];
		// }
		// for(auto &x : *it)
		// {

      if(header_count == 0 && x != '>')
      {
        return List::create(_["isFasta"] = false, _["failMsg"] = "First non-blank line was not FASTA header line beginning with '>' on line ");// + static_cast<std::ostringstream*>( &(std::ostringstream() << line_count)->str() ));
      }
			if(count == 0 && x == '>')
			{
				header_count++;
				break;
			}
			count++;
			switch (x)
			{
				case 'A':case 'a':
				case 'C':case 'c':
				case 'G':case 'g':
				case 'T':case 't':
				case 'R':case 'r':
				case 'Y':case 'y':
				case 'S':case 's':
				case 'W':case 'w':
				case 'K':case 'k':
				case 'M':case 'm':
				case 'B':case 'b':
				case 'D':case 'd':
				case 'H':case 'h':
				case 'V':case 'v':
				case 'N':case 'n':
					continue;
				default:
					std::string tmp;
					std::stringstream ss;
					ss << x;
					ss >> tmp;
					return List::create(_["isFasta"] = false, _["failMsg"] = "Unexpected character '" + tmp + "' on line ");// + static_cast<std::ostringstream*>( &(std::ostringstream() << line_count) )-str() + " column " + static_cast<std::ostringstream*>( &(std::ostringstream() << count)->str() ));
			}
		}
	}
	if (header_count > 0)
	{
		return List::create(_["isFasta"] = true, _["failMsg"] = "");
	}
	else
	{
		return List::create(_["isFasta"] = false, _["failMsg"] = "No headers (i.e. lines starting with '>') in file");
	}
}

//' 
//' Convert Japanese alphanumerics to ASCII alphanumerics
//' 
//' @title halfwidthen
//' @name halfwidthen
//' 
//' @param x A string to convert
//' 
//' @examples
//' x = c("\uff10", "\uff11")
//' halfwidthen(x)
//'
//' @export
// [[Rcpp::export]]
CharacterVector halfwidthen(CharacterVector x) {
  CharacterVector str(x.size());
  std::transform(x.begin(), x.end(), str.begin(), halfwidthen_one);
  return str;
}