C++ shift函数代码示例

/***
 When removing a set from the partial solution
 1. Indicate that the column is no longer selected (x)
 2. Remove cost of column from partial cost (fx)
 3. Increment # of un-used columns (un_cols)
 4. Decrement # of columns covering each row (ncol_cover)
 5. Remove column from all columns covering row i (col_cover)
 6. If a row is now uncovered, increment un_rows
 7. If a row is now uncovered, indicate it (y)
 **/
void removeSet(instance_t* inst, solution_t* sol, int colidx) {
    sol->x[colidx] = 0;
    sol->fx -= inst->cost[colidx];
    sol->un_cols += 1;
    for (int i = 0; i < inst->nrow[colidx]; i++) {
        int rowidx = inst->row[colidx][i];
        for (int j = 0; j < sol->ncol_cover[rowidx]; j++) {
            if (sol->col_cover[rowidx][j] == colidx) {
                sol->col_cover[rowidx][j] = -1;
                shift(sol, rowidx, j);
                break;
            }
        }
        sol->ncol_cover[rowidx] -= 1;
        if (sol->ncol_cover[rowidx] <= 0) {
            sol->un_rows += 1;
            sol->y[rowidx] = 0;
        }
    }
}

void conv_flaw(const cv::Mat& imgOriginal, const cv::Mat& kernel, cv::Mat& out, const bool& corr)
{
  cv::Mat source;
  imgOriginal.copyTo(source);
  cv::Mat kernelPadded = cv::Mat::zeros(source.size(), source.type());
  if(kernel.size().height > kernelPadded.size().height || kernel.size().width > kernelPadded.size().width)
  {
    throw CustomException("Kernel padded bigger than image.");
  }
  kernel.copyTo(selectCentralROI(kernelPadded, kernel.size()));
  //Divided by 2.0 instead of 2 to consider the result as double instead of as an int
  //The +1 in the shift changes slightly the finest plane in the wavelet,
  shift(kernelPadded, kernelPadded, std::ceil(kernelPadded.cols/2.0), std::ceil(kernelPadded.rows/2.0));

  cv::Mat kernelPadded_ft, input_ft, output_ft;
  cv::dft(kernelPadded, kernelPadded_ft, cv::DFT_COMPLEX_OUTPUT + cv::DFT_SCALE);
  cv::dft(source, input_ft, cv::DFT_COMPLEX_OUTPUT + cv::DFT_SCALE);
  cv::mulSpectrums(input_ft, kernelPadded_ft.mul(kernelPadded.total()), output_ft, cv::DFT_COMPLEX_OUTPUT, corr);
  cv::idft(output_ft, out, cv::DFT_REAL_OUTPUT);
}

Score::Score(Alignment& alg){
	PRECISION = 15.;	// the default value of PRECISION
	LAMBDA = .125;
	alignment = alg;
	alpha_exponent = 1.;
	logR = calculate_logR();
	std::vector <std::vector<double> > temp = shift(logR);
	alpha_exponent = find_alpha_exponent(temp);
	rescaled_R = re_scale(temp, alpha_exponent);

	laplacian_determinant = calculate_determinant(laplacian_of(rescaled_R), rescaled_R.size() - 1);

	tf = "TF-Unknown";

	ParameterFile p;
	parameters = p;

	BackgroundModel bg (parameters.give_background());
	background = bg;
}

bool funcPLUS(ParserParam &param, Token *tok){
	switch(param.stack.back()){
		case 78:
			shift(param,tok,81);
			break;
		case 83:
			if(!rule46(param)) return false;
			break;
		case 85:
			if(!rule45(param)) return false;
			break;
		case 86:
			if(!rule47(param)) return false;
			break;
		case 88:
			if(!rule48(param)) return false;
			break;
		case 91:
			if(!rule49(param)) return false;
			break;
		case 92:
			if(!rule50(param)) return false;
			break;
		case 95:
			if(!rule51(param)) return false;
			break;
		case 98:
			if(!rule52(param)) return false;
			break;
		case 99:
			if(!rule53(param)) return false;
			break;
		case 113:
			if(!rule68(param)) return false;
			break;
		default:
			return false;
		break;
	}
	return true;
}

/*
 * 加密
 *
 * @param key    密钥 { a, b }
 * @param src    待加密的字符串
 * @param dest   经过加密后的字符串
 */
char * encrypt(int* key, char* src, char* dest)
{
    char *pSrc  = src;
    char *pDest = dest;

    if (gcd(key[0], WIDTH) != 1)
    {
        printf("Error: a 与 m 不互素");
        exit(-1);
    }

    for (int i = 0; *pSrc; ++i, ++pSrc, ++pDest)
    {
        if (!isalpha(*pSrc))
            continue;

        *pDest = shift(key, toupper(*pSrc));
    }

    return dest;
}

	void StateItem::move(const int & action) {
		switch (decodeAction(action)) {
		case NO_ACTION:
			return;
		case SHIFT:
			shift();
			return;
		case REDUCE:
			reduce();
			return;
		case ARC_LEFT:
			arcLeft(action - AL_FIRST + 1);
			return;
		case ARC_RIGHT:
			arcRight(action - AR_FIRST + 1);
			return;
		case POP_ROOT:
			popRoot();
			return;
		}
	}

dem subst (int n, dem y, dem z)
{
    if (y == NULL)
        return NULL;
    if (node(y) == node_var)
    {
        if (level(y) == n)
        	return z;
	if (level(y) > n)
		return mkdem (node_var, level(y)-1, NULL, NULL, NULL);
    }
    if (node(y) == node_ap)
	return ap (subst (n, sd0(y), z),
		   subst (n, sd1(y), z));
    if (node(y) == node_lambda)
	return lambda (subst (n+1, sd0(y), shift (0, 1, z)));
    /* return y; */
    return mkdem (node(y), level(y), name(y),
			subst (n, sd0(y), z),
			subst (n, sd1(y), z));
}

bool LightColliderSphere::intersect(Vector3D start, Vector3D vec) {
    
    Vector3D shift(position - start);
    double a = vec.magnitudeSquared();
    double b = -2 * (vec * shift);
    double c = shift.magnitudeSquared() - radiusSquared;
    if(a == 0) {
        return false;
    }
    c = b * b - 4 * a * c;
    if(c < 0) {
        return false;
    }
    c = (-b - sqrt(c)) / (2 * a);

    if(c > 0 && c < 1) {
        
        return true;
    }
    return false;
}

/***************************************************************************
 PRIVATE FUNCTIONS
 ***************************************************************************/
uint8_t lsm303_write8(byte address, byte reg, byte value)
{

  int ret;
  byte buf[1];
 
  buf[0] = value;
  ret = 0;
  ret = i2c_writeReg(address, reg, buf, 1);

  if(ret!=0)
    {
#ifdef DEBUG
      shift(0x7777);
      _delay_ms(1000);
#endif
      return 1;
    }

  return 0;
}

cv::Mat crosscorrelation_direct(const cv::Mat& A, const cv::Mat& B)
{  //For testing pourposes only
  cv::Mat aPadded, bPadded;
  cv::copyMakeBorder(A, aPadded, 0, A.rows, 0, A.cols, cv::BORDER_CONSTANT, cv::Scalar(0.0, 0.0));
  cv::copyMakeBorder(B, bPadded, 0, B.rows, 0, B.cols, cv::BORDER_CONSTANT, cv::Scalar(0.0, 0.0));

  cv::Mat C = cv::Mat::zeros(aPadded.size(), aPadded.type());
  cv::Mat conjA = conjComplex(aPadded);
  for(int i=0; i < aPadded.cols; ++i)              // rows
  {
    for(int j=0; j < aPadded.rows; ++j)          // columns
    {
      cv::Mat shifted, prod;
      shift(conjA,shifted,aPadded.cols-i,aPadded.rows-j);
      cv::mulSpectrums(shifted,bPadded,prod, cv::DFT_COMPLEX_OUTPUT);
      cv::Scalar s = cv::sum(prod);
      C.at<std::complex<float> >(i,j) = std::complex<float>(s.val[0],s.val[1]);
    }
  }
  return C;
}

void convolveDFT(const cv::Mat& imgOriginal, const cv::Mat& kernel, cv::Mat& out, const bool& corr, const bool& full)
{ //this method is also valid for complex image and kernel, set DFT_COMPLEX_OUTPUT then
  //convolution in fourier space, keep code for future use
  //CONVOLUTION_FULL: Return the full convolution, including border
  //to completeley emulate filter2D operation, image should be first double sized and then cut back to origianl size
  cv::Mat source, kernelPadded;
  const int marginSrcTop = corr ? std::ceil((kernel.rows-1)/2.0) : std::floor((kernel.rows-1)/2.0);
  const int marginSrcBottom = corr ? std::floor((kernel.rows-1)/2.0) : std::ceil((kernel.rows-1)/2.0);
  const int marginSrcLeft = corr ? std::ceil((kernel.cols-1)/2.0) : std::floor((kernel.cols-1)/2.0);
  const int marginSrcRight = corr ? std::floor((kernel.cols-1)/2.0) : std::ceil((kernel.cols-1)/2.0);
  cv::copyMakeBorder(imgOriginal, source, marginSrcTop, marginSrcBottom, marginSrcLeft, marginSrcRight, cv::BORDER_CONSTANT);

  const int marginKernelTop = std::ceil((source.rows-kernel.rows)/2.0);
  const int marginKernelBottom = std::floor((source.rows-kernel.rows)/2.0);
  const int marginKernelLeft = std::ceil((source.cols-kernel.cols)/2.0);
  const int marginKernelRight = std::floor((source.cols-kernel.cols)/2.0);
  cv::copyMakeBorder(kernel, kernelPadded, marginKernelTop, marginKernelBottom, marginKernelLeft, marginKernelRight, cv::BORDER_CONSTANT);

  //Divided by 2.0 instead of 2 to consider the result as double instead of as an int
  //The +1 in the shift changes slightly the finest plane in the wavelet,
  shift(kernelPadded, kernelPadded, std::ceil(kernelPadded.cols/2.0), std::ceil(kernelPadded.rows/2.0));

  cv::Mat kernelPadded_ft, input_ft, output_ft;
  cv::dft(kernelPadded, kernelPadded_ft, cv::DFT_COMPLEX_OUTPUT + cv::DFT_SCALE);
  cv::dft(source, input_ft, cv::DFT_COMPLEX_OUTPUT + cv::DFT_SCALE);
  cv::mulSpectrums(input_ft, kernelPadded_ft.mul(kernelPadded.total()), output_ft, cv::DFT_COMPLEX_OUTPUT, corr);
  
  if(imgOriginal.channels() == 1 && kernel.channels() == 1) cv::idft(output_ft, out, cv::DFT_REAL_OUTPUT);
  else cv::idft(output_ft, out, cv::DFT_COMPLEX_OUTPUT);
  
  if(!full)
  {
    //colRange and rowRange are semi-open intervals. first included, last is not
    //this frist option is what i think should be the correct one, but the next is what filter2D function gives for this inputs
//    out = out.colRange(marginSrcLeft, out.cols - marginSrcRight).
//              rowRange(marginSrcTop, out.rows - marginSrcBottom);
        out = out.colRange(marginSrcRight, out.cols - marginSrcLeft).
                  rowRange(marginSrcBottom, out.rows - marginSrcTop);
  }
}

//---------------------------------------------------------------------------------------
void TableCellSizer::reposition_cells()
{
    //AWARE: row 0 is correctly positioned, so we start moving from row 1.
    //In horizontal cells are correctly positioned, so shift is only in vertical.

    int iH = m_iFirstRow * m_numColumns;
    USize shift(0.0f, 0.0f);
    for (int iRow=1; iRow < m_numRows; ++iRow)
    {
        shift.height += m_heights[iH];
        int iCell = (m_iFirstRow + iRow) * m_numColumns;
        for (int iCol=0; iCol < m_numColumns; ++iCol, ++iCell)
        {
            if (m_cellLayouters[iCell] != nullptr)
            {
                GmoBox* pCellBox = m_cellLayouters[iCell]->get_item_main_box();
                pCellBox->shift_origin(shift);
            }
        }
        iH += m_numColumns;
    }
}

void turn() //обработка ходов
{
	int direction = 0;
	bool moved;
	while (true)
	{
		direction = controls();
		moved = shift(direction);
		int number = cells_check();
		if (!move_check() && !number)
		{
			lose();
			return;
		}
		if (moved)
		{
			add_2(number);
			printfield();
			Sleep(50);
		}
	}
}

/* autolinking means that all inline html is <a href'ified>.   A
 * autolink url is alphanumerics, slashes, periods, underscores,
 * the at sign, colon, and the % character.
 */
static int
maybe_autolink(MMIOT *f)
{
    register int c;
    int size;

    /* greedily scan forward for the end of a legitimate link.
     */
    for ( size=0; (c=peek(f, size+1)) != EOF; size++ )
	if ( c == '\\' ) {
	     if ( peek(f, size+2) != EOF )
		++size;
	}
	else if ( isspace(c) || strchr("'\"()[]{}<>`", c) )
	    break;

    if ( (size > 1) && process_possible_link(f, size) ) {
	shift(f, size);
	return 1;
    }
    return 0;
}

vector<Shift> ShiftRepo::getWeeklyShifts(string start_date, string end_date, int type_selected)
{
    db.open();

    stringstream sqlQuery;

    sqlQuery << "SELECT * FROM Shifts WHERE (date BETWEEN '" << start_date << "'";
    sqlQuery << " AND '" << end_date << "') AND (shiftID BETWEEN 1 AND 13) AND type = " << type_selected;
    sqlQuery << " ORDER BY date ASC";

    QSqlQuery query(db);

    bool success = query.exec(QString::fromStdString(sqlQuery.str()));
    qDebug() << query.lastQuery();
    if(!success)
    {
        qDebug() << "Error in getting weekly shifts";
        qDebug() << query.lastError().text();
    }

    vector<Shift> shifts;

    while(query.next())
    {
        QString raw_date = query.value("date").toString();
        QDate date = stringToDate(raw_date);
        int id = query.value("shiftID").toInt();
        bool type = query.value("type").toBool();
        QString name = query.value("name").toString();
        double hours = query.value("hours").toDouble();
        double wages = query.value("wages").toDouble();

        Shift shift(date, id, type, name, hours, wages);
        shifts.push_back(shift);
    }

    return shifts;
}