//------------------------------MAIN------------------------------------------
int main()
{
int key,lev1,lev2,c,d,level=0,FLAG;
printf("Enter the root:\n");
scanf("%d",&key);
struct node* root=(struct node*)malloc(sizeof(struct node));
root->key=key;
create(root->key,root);
printf("\n\nTraversal\n");
traverse(root);
while(FLAG!=0)
{
printf("\nEnter 2 nodes between which you want to find relation:\n");
scanf("%d%d",&c,&d);
lev1=relation(c,root,level);
lev2=relation(d,root,level);
if(lev1==-1 || lev2==-1)
printf("\nWrong entries..!! Some of the element is not found..!\n");
else
{
printf("LEVEL1: %d \t LEVEL2: %d\n ",lev1,lev2);
if(lev1>lev2)
printf("\n%d is at a level %d greater than %d\n\n",c,(lev1-lev2),d);
else if(lev2>lev1)
printf("\n%d is at a level %d greater than %d\n\n",d,(lev2-lev1),c);
else if(lev1=lev2)
printf("Both are at same level:%d\n",lev1);
}
printf("check again?\n");
scanf("%d",&FLAG);
}
return 0;
}
/*---------------------------------------------------------------------------*/
static void expr(struct typevalue *r1)
{
struct typevalue r2;
int op;
relation(r1);
op = current_token;
DEBUG_PRINTF("logicrelation: token %d\n", op);
/* FIXME: unclear the while is correct here. It's not correct in most
BASIC to write A > B > C, rather relations should be two part linked
with logic */
while(op == TOKENIZER_AND ||
op == TOKENIZER_OR) {
tokenizer_next();
relation(&r2);
/* No type checks needed on relations */
DEBUG_PRINTF("logicrelation: %d %d %d\n", r1->d.i, op, r2.d.i);
switch(op) {
case TOKENIZER_AND:
r1->d.i = r1->d.i & r2.d.i;
break;
case TOKENIZER_OR:
r1->d.i = r1->d.i | r2.d.i;
break;
}
op = current_token;
}
r1->type = TYPE_INTEGER;
}
bool Board::canMoveJiang(int moveid, int killid, int row, int col)
{
// 可直接吃对方将
if (killid != -1 && _s[killid]._type == Stone::JIANG)
{
return canMoveChe(moveid, killid, row, col);
}
GetRowCol(row1, col1, moveid);
int r = relation(row1, col1, row, col);
if (r != 1 || r != 10) {
return false;
}
if (col < 3 || col > 5) {
return false;
}
if (isBottomSide(moveid)) {
if (row < 7) {
return false;
}
}
else {
if (row > 2) {
return false;
}
}
return true;
}
static u8 comfirm(void)
{
s32 i = 0;
u8 buf[32];
// memcpy(&buf[ADDR_MAX_LENGTH - cmd_head.addr_len], &cmd_head.flag_addr, cmd_head.addr_len);
memcpy(buf, &cmd_head.flag_addr, cmd_head.addr_len);
for (i = 0; i < cmd_head.times; i++)
{
if (tool_i2c_read(buf, 1) <= 0)
{
WARNING("Read flag data failed!\n");
return fail;
}
if (true == relation(buf[ADDR_MAX_LENGTH], cmd_head.flag_val, cmd_head.flag_relation))
{
DEBUG("value at flag addr:0x%02x\n", buf[ADDR_MAX_LENGTH]);
DEBUG("flag value:0x%02x\n", cmd_head.flag_val);
break;
}
msleep(cmd_head.circle);
}
if (i >= cmd_head.times)
{
WARNING("Didn't get the flag to continue!\n");
return fail;
}
return success;
}
void TestDatabaseLoader::createJoinRelations() {
std::vector<std::string> rel_names = { "a", "b", "c", "d" };
std::vector<std::vector<std::pair<std::string, TypeID>>> rel_columns = {
{ { "w", kInt }, { "x", kInt }, { "y", kInt }, { "z", kInt } },
{ { "w", kInt }, { "x", kInt } },
{ { "x", kInt }, { "y", kInt } },
{ { "y", kInt }, { "z", kInt } }
};
for (std::size_t rel_idx = 0; rel_idx < rel_names.size(); ++rel_idx) {
std::unique_ptr<CatalogRelation> relation(
new CatalogRelation(&catalog_database_,
rel_names[rel_idx],
-1 /* id */,
true /* temporary */));
const std::vector<std::pair<std::string, TypeID>> &columns = rel_columns[rel_idx];
int attr_id = -1;
for (std::size_t col_idx = 0; col_idx < columns.size(); ++col_idx) {
relation->addAttribute(new CatalogAttribute(
relation.get(),
columns[col_idx].first,
TypeFactory::GetType(columns[col_idx].second),
++attr_id));
}
catalog_database_.addRelation(relation.release());
}
}
shared_ptr<Relation> ServicesDbReader::_resultToRelation(const QSqlQuery& resultIterator,
const OsmMap& map, long mapId)
{
const long relationId = resultIterator.value(0).toLongLong();
const long newRelationId = _mapElementId(map, ElementId::relation(relationId)).getId();
shared_ptr<Relation> relation(
new Relation(
_status,
newRelationId,
ServicesDb::DEFAULT_ELEMENT_CIRCULAR_ERROR/*,
"collection"*/)); //TODO: services db doesn't support relation "type" yet
relation->setTags(ServicesDb::unescapeTags(resultIterator.value(ServicesDb::RELATIONS_TAGS)));
_addTagsToElement(relation);
//TODO: read these out in batch at the same time the element results are read
vector<RelationData::Entry> members = _database.selectMembersForRelation(mapId, relationId);
for (size_t i = 0; i < members.size(); ++i)
{
members[i].setElementId(_mapElementId(map, members[i].getElementId()));
}
relation->setMembers(members);
return relation;
}
char *factor()
{
char *tempvar;
if( match(NUM_OR_ID) )
{
/* Print the assignment instruction. The %0.*s conversion is a form of
* %X.Ys, where X is the field width and Y is the maximum number of
* characters that will be printed (even if the string is longer). I'm
* using the %0.*s to print the string because it's not \0 terminated.
* The field has a default width of 0, but it will grow the size needed
* to print the string. The ".*" tells printf() to take the maximum-
* number-of-characters count from the next argument (yyleng).
*/
printf(" %s = %0.*s\n", tempvar = newname(), yyleng, yytext );
advance();
}
else if( match(LP) )
{
advance();
//tempvar = expression();
tempvar = relation();
if( match(RP) )
advance();
else
fprintf(stderr, "%d: Mismatched parenthesis\n", yylineno );
}
else
fprintf( stderr, "%d: Number or identifier expected\n", yylineno );
return tempvar;
}
shared_ptr<Relation> ServicesDbReader::_resultToRelation(const QSqlQuery& resultIterator,
const OsmMap& map)
{
const long relationId = resultIterator.value(0).toLongLong();
const long newRelationId = _mapElementId(map, ElementId::relation(relationId)).getId();
shared_ptr<Relation> relation(
new Relation(
_status,
newRelationId,
resultIterator.value(ServicesDb::RELATIONS_CHANGESET).toLongLong(),
resultIterator.value(ServicesDb::RELATIONS_VERSION).toLongLong(),
OsmUtils::fromTimeString(
resultIterator.value(ServicesDb::RELATIONS_TIMESTAMP).toDateTime().toString("yyyy-MM-ddThh:mm:ssZ")),
ServicesDb::DEFAULT_ELEMENT_CIRCULAR_ERROR/*,
"collection"*/)); /// @todo services db doesn't support relation "type" yet
relation->setTags(ServicesDb::unescapeTags(resultIterator.value(ServicesDb::RELATIONS_TAGS)));
_addTagsToElement(relation);
/// @todo read these out in batch at the same time the element results are read
vector<RelationData::Entry> members = _database.selectMembersForRelation(relationId);
for (size_t i = 0; i < members.size(); ++i)
{
members[i].setElementId(_mapElementId(map, members[i].getElementId()));
}
relation->setMembers(members);
return relation;
}
bool Board::canMoveBing(int moveid, int, int row, int col)
{
GetRowCol(row1, col1, moveid);
int r = relation(row1, col1, row, col);
// 首先判断兵只能走一步
if (r != 1 && r != 10) {
return false;
}
if (isBottomSide(moveid)) { // 下面一方的棋子
if (row > row1) { // 如果目标行大于原始行，相当于并在后退
return false;
}
if (row1 >= 5 && row == row1) { // 还没有过河就想横着走
return false;
}
}
else { // 上面一方的棋子
if (row1 > row) { // 如果目标行小于原始行，相当于兵在后退
return false;
}
if (row <= 4 && row == row1) { // 还没有过河就想横着走
return false;
}
}
return true;
}
/*---------------------------------------------------------------------------*/
static void
if_statement(void)
{
int r;
accept(TOKENIZER_IF);
r = relation();
DEBUG_PRINTF("if_statement: relation %d\n", r);
accept(TOKENIZER_THEN);
if(r) {
statement();
} else {
do {
tokenizer_next();
} while(tokenizer_token() != TOKENIZER_ELSE &&
tokenizer_token() != TOKENIZER_CR &&
tokenizer_token() != TOKENIZER_ENDOFINPUT);
if(tokenizer_token() == TOKENIZER_ELSE) {
tokenizer_next();
statement();
} else if(tokenizer_token() == TOKENIZER_CR) {
tokenizer_next();
}
}
}
bool Board::canMoveXiang(int moveid, int, int row, int col)
{
GetRowCol(row1, col1, moveid);
int r = relation(row1, col1, row, col);
if (r != 22) { // 象走田，所以r应该等于22
return false;
}
// 看象眼有没有棋子
int rEye = (row + row1) / 2;
int cEye = (col + col1) / 2;
if (getStoneId(rEye, cEye) != -1) {
return false;
}
// 判断是否在棋盘的下方
if (isBottomSide(moveid)) {
if (row < 4) {
return false;
}
}
else {
if (row > 5) {
return false;
}
}
return true;
}
bool Board::canMoveShi(int moveid, int, int row, int col)
{
// 移动步长一个格子对角线
GetRowCol(row1, col1, moveid);
int r = relation(row1, col1, row, col);
if (r != 11) {
return false;
}
if (col < 3 || col > 5) {
return false;
}
if (isBottomSide(moveid)) {
if (row < 7) {
return false;
}
}
else {
if (row > 2) {
return false;
}
}
return true;
}
/*******************************************************
Function:
Comfirm function.
Input:
None.
Output:
Return write length.
********************************************************/
static u8 comfirm(void)
{
s32 i = 0;
u8 buf[32];
// memcpy(&buf[GTP_ADDR_LENGTH - cmd_head.addr_len], &cmd_head.flag_addr, cmd_head.addr_len);
// memcpy(buf, &cmd_head.flag_addr, cmd_head.addr_len);//Modified by Scott, 2012-02-17
memcpy(buf, cmd_head.flag_addr, cmd_head.addr_len);
for (i = 0; i < cmd_head.times; i++)
{
if (tool_i2c_read(buf, 1) <= 0)
{
GTP_ERROR("Read flag data failed!");
return FAIL;
}
if (true == relation(buf[GTP_ADDR_LENGTH], cmd_head.flag_val, cmd_head.flag_relation))
{
GTP_DEBUG("value at flag addr:0x%02x.", buf[GTP_ADDR_LENGTH]);
GTP_DEBUG("flag value:0x%02x.", cmd_head.flag_val);
break;
}
msleep(cmd_head.circle);
}
if (i >= cmd_head.times)
{
GTP_ERROR("Didn't get the flag to continue!");
return FAIL;
}
return SUCCESS;
}
// ---------------------------------------------------------------------------
// CWlanBgScan::TimeRelationToRange
// ---------------------------------------------------------------------------
//
CWlanBgScan::TRelation CWlanBgScan::TimeRelationToRange( const TTime& aTime, TUint aRangeStart, TUint aRangeEnd ) const
{
#ifdef _DEBUG
TBuf<KWlanBgScanMaxDateTimeStrLen> dbgString;
TRAP_IGNORE( aTime.FormatL( dbgString, KWlanBgScanDateTimeFormat2 ) );
DEBUG1( "CWlanBgScan::TimeRelationToRange() - time: %S", &dbgString );
#endif
TDateTime dateTime( aTime.DateTime() );
TUint timeToCheck = ( dateTime.Hour() * KGetHours ) + dateTime.Minute();
DEBUG2( "CWlanBgScan::TimeRelationToRange() - range: %04u - %04u", aRangeStart, aRangeEnd );
CWlanBgScan::TRelation relation( ESmaller );
if( aRangeStart == aRangeEnd )
{
DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EGreater" );
relation = EGreater;
}
else if( aRangeStart > aRangeEnd )
{
DEBUG( "CWlanBgScan::TimeRelationToRange() - range crosses the midnight" );
/**
* As range crosses midnight, there is no way for the relation to be ESmaller.
*/
if( timeToCheck < aRangeEnd || timeToCheck >= aRangeStart )
{
DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EInsideRange" );
relation = EInsideRange;
}
else
{
DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EGreater" );
relation = EGreater;
}
}
else
{
if( timeToCheck < aRangeStart )
{
DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: ESmaller" );
relation = ESmaller;
}
else if( timeToCheck >= aRangeStart && timeToCheck < aRangeEnd )
{
DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EInsideRange" );
relation = EInsideRange;
}
else
{
DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EGreater" );
relation = EGreater;
}
}
return relation;
}
//19. <关系表达式>—> <表达式> <关系> <表达式>
TFexit relationexpression(){
Val v1 = expression();
int re = relation();
Val v2 = expression();
quadruples.push_back(Quadruple(sno++, re, v1, v2));
quadruples.push_back(Quadruple(sno++,0,Val(),Val()));//无条件跳转op=0
return TFexit(sno - 2, sno - 1);
}
virtual double computeError(const double* pVector)
{
GData* pData = m_pLearner->instances();
if(!pData)
return 1e308;
GKNN temp(m_pLearner->neighborCount(), m_pLearner->getRand());
temp.enableIncrementalLearning(pData->relation(), m_labelDims, NULL, NULL);
GVec::copy(temp.metric()->scaleFactors(), pVector, relation()->size());
return temp.heuristicValidate(pData, m_labelDims, m_pLearner->getRand());
}
static void if_statement (void)
{
int r, to;
accept(T_IF);
r = relation();
accept(T_THEN);
to = tokenizer_num();
accept(T_NUMBER);
accept(T_EOL);
if (r)
jump_linenum(to);
}
void Parser::boolFactor()
{
if (Cradle::isBoolean(input.getChar())) {
if (input.getBoolean()) {
output.emitLine("MOVE #-1,D0");
} else {
output.emitLine("CLR D0");
}
} else {
relation();
}
}
void AttachRelationFunc::operator()(sql::ResultSet* rs)
{
int person_id1 = rs->getInt(2);
int person_id2 = rs->getInt(3);
double similarity = rs->getDouble(4);
string rel_type = rs->getString(5);
if (person_id1 < 0 || person_id2 < 0 || person_id1 >= authors->size() || person_id2 >= authors->size())
{
return;
}
Author* author = authors->at(person_id1);
if(!author)
{
return;
}
assert(author!=NULL);
AuthorRelation relation(person_id1, person_id2, similarity, rel_type);
author->Coauthor.push_back(relation);
int tmp = author->Coauthor.size() - 1;
while (tmp > 0 && author->Coauthor[tmp].similarity > author->Coauthor[tmp - 1].similarity)
{
AuthorRelation temp = author->Coauthor[tmp];
author->Coauthor[tmp] = author->Coauthor[tmp - 1];
author->Coauthor[tmp - 1] = temp;
tmp--;
}
author = authors->at(person_id2);
if(!author)
{
return;
}
assert(author!=NULL);
relation.pid1 = person_id2;
relation.pid2 = person_id1;
author->Coauthor.push_back(relation);
tmp = author->Coauthor.size() - 1;
while (tmp > 0 && author->Coauthor[tmp].similarity > author->Coauthor[tmp - 1].similarity)
{
AuthorRelation temp = author->Coauthor[tmp];
author->Coauthor[tmp] = author->Coauthor[tmp - 1];
author->Coauthor[tmp - 1] = temp;
tmp--;
}
}
void CMPolynomial::level2(double& result) // relational
{
register int op;
double hold;
level3(result);
while (isrelation(token)) {
op = token;
get_token();
level3(hold);
relation(op,result,hold);
}
}
// -----------------------------------------------------------------------------
// Adds mailbox observer and subscribes to plugin mailbox events if there
// were no previous observers.
// -----------------------------------------------------------------------------
void CEmailMailbox::TObserverEventMapper::AddObserverL(
MMailboxContentObserver& aObserver )
{
TIdentityRelation<MMailboxContentObserver> relation(
&CEmailMailbox::TObserverEventMapper::Equals );
if ( iClientObservers.Find( &aObserver, relation ) == KErrNotFound )
{
const TInt count( iClientObservers.Count() );
if ( !count )
{
iPlugin->SubscribeMailboxEventsL( iFsMailboxId, *this );
}
iClientObservers.AppendL( &aObserver );
}
}
// -----------------------------------------------------------------------------
// Removes an observer and removes event subscription if the observer was
// last in observer array.
// -----------------------------------------------------------------------------
void CEmailMailbox::TObserverEventMapper::RemoveObserver(
MMailboxContentObserver& aObserver )
{
TIdentityRelation<MMailboxContentObserver> relation(
&CEmailMailbox::TObserverEventMapper::Equals );
const TInt index( iClientObservers.Find( &aObserver, relation ) );
if ( index != KErrNotFound )
{
iClientObservers.Remove( index );
const TInt count( iClientObservers.Count() );
if ( !count )
{
iPlugin->UnsubscribeMailboxEvents( iFsMailboxId, *this );
}
}
}
// -----------------------------------------------------------------------------
// CMediatorServerObjectHandler::FindDomain
// Returns pointer to found domain
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CDomain* CMediatorServerObjectHandler::FindDomain( const TUid aDomain )
{
// Create utilities to be used in find
TIdentityRelation<CDomain> relation( CompareDomains );
iSearchDomain->SetDomainUid( aDomain );
// Find the item from array
TInt index = iDomainList.Find( iSearchDomain, relation );
// Then return domain, if found.
CDomain* domain = NULL;
if ( index != KErrNotFound )
{
domain = iDomainList[index];
}
return domain;
}
int main(int argc, char *argv[])
{
std::vector<std::pair<FloatVector, FloatVector>> rel;
for(float x = 1; x < 10; x += 1) {
for(float y = 1; y < 10; y += 1) {
FloatVector point;
point.push_back(x);
point.push_back(y);
point.push_back(1);
FloatVector res;
res.push_back(x);
res.push_back(y + 3);
res.push_back(1);
rel.push_back(std::make_pair(point, res));
}
}
Relation<FloatVector, FloatVector> relation(rel);
std::vector<unsigned int> structure = { 3, 3};
NeuralNet* nn = new NeuralNet(relation, structure);
nn->status();
nn->print();
//nn->print();
Gecode::BAB<NeuralNet> se(nn);
Gecode::Gist::Print<NeuralNet> p("Print solution");
Gecode::Gist::Options o;
o.inspect.click(&p);
Gecode::Gist::bab(nn, o);
delete nn;
/*
if(NeuralNet* nn1 = se.next()) {
nn1->print();
delete nn1;
}*/
return 0;
}
QString ProfimaxRelationalModel::selectStatement() const
{
QString query = QSqlRelationalTableModel::selectStatement();
//QMessageBox::critical(0,"",r->field(1));
//query.replace("city_name_2","city_name");
int i =query.indexOf(" ");
int from = query.indexOf(" FROM ");
int j;
int index=0;
QString fields = QString("");
while (i<from){
j=i+1;
i=query.indexOf(",",i+1);
if (i>from or i==-1)
i=from;
QString f = query.mid(j,i-j);
if (f.indexOf("relTblAl")!=-1){
if (relation(index).isValid()){
f=f.left(f.indexOf(" AS "));
f=f+QString(" AS ")+QString("\"%1\"").arg(this->record().fieldName(index));
}
}
fields += QString("%1,").arg(f);
//QMessageBox::critical(0,"",f);
index++;
}
fields.chop(1);
query = QString("SELECT ")+fields+query.mid(from);
//QMessageBox::critical(0,"",query);
return query;
}
QVariant RelationItemModel::data( const QModelIndex &index, int role ) const
{
if ( role == Qt::TextAlignmentRole ) {
return headerData( index.column(), Qt::Horizontal, role );
}
QVariant result;
Relation *r = relation( index );
if ( r != 0 ) {
result = m_relationmodel.data( r, index.column(), role );
}
if ( result.isValid() ) {
if ( role == Qt::DisplayRole && result.type() == QVariant::String && result.toString().isEmpty()) {
// HACK to show focus in empty cells
result = " ";
}
return result;
}
return result;
}
AlbumXmlHandler(MusicBrainzAlbumInfo& albumInfo) : SimpleSaxHandler<AlbumXmlHandler>("metadata"), m_albumInfo(albumInfo), m_bTargetIsUrl(false)
{
Node& meta (getRoot()); meta.onEnd = &AlbumXmlHandler::onMetaEnd;
Node& rel (makeNode(meta, "release")); rel.onStart = &AlbumXmlHandler::onRelStart;
Node& albTitle (makeNode(rel, "title")); albTitle.onChar = &AlbumXmlHandler::onAlbTitleChar;
Node& asin (makeNode(rel, "asin")); asin.onChar = &AlbumXmlHandler::onAsinChar;
Node& albArtist (makeNode(rel, "artist"));
Node& albArtistName (makeNode(albArtist, "name")); albArtistName.onChar = &AlbumXmlHandler::onAlbArtistNameChar;
Node& albRelEvents (makeNode(rel, "release-event-list"));
Node& albEvent (makeNode(albRelEvents, "event")); albEvent.onStart = &AlbumXmlHandler::onAlbEventStart;
Node& albTrackList (makeNode(rel, "track-list"));
Node& track (makeNode(albTrackList, "track")); track.onStart = &AlbumXmlHandler::onTrackStart;
Node& trackTitle (makeNode(track, "title")); trackTitle.onChar = &AlbumXmlHandler::onTrackTitleChar;
Node& trackArtist (makeNode(track, "artist"));
Node& trackArtistName (makeNode(trackArtist, "name")); trackArtistName.onChar = &AlbumXmlHandler::onTrackArtistName;
Node& relationList (makeNode(rel, "relation-list")); relationList.onStart = &AlbumXmlHandler::onRelationListStart;
Node& relation (makeNode(relationList, "relation")); relation.onStart = &AlbumXmlHandler::onRelationStart;
m_albumInfo.m_eVarArtists = AlbumInfo::VA_SINGLE;
}
bool RelationItemModel::setData( const QModelIndex &index, const QVariant &value, int role )
{
if ( ! index.isValid() ) {
return ItemModelBase::setData( index, value, role );
}
if ( ( flags(index) & Qt::ItemIsEditable ) == 0 || role != Qt::EditRole ) {
return false;
}
Relation *r = relation( index );
switch (index.column()) {
case 0: return false;
case 1: return false;
case 2: return setType( r, value, role );
case 3: return setLag( r, value, role );
default:
qWarning("data: invalid display value column %d", index.column());
return false;
}
return false;
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL");
if(!createConnection(db))
return 1;
/*
QSqlQueryModel * mode = new QSqlQueryModel;
mode->setQuery("select prod_id, vend_name, prod_name, prod_price from products, vendors where products.vend_id = vendors.vend_id", db);
mode->setHeaderData(0, Qt::Horizontal, "prod_id");
mode->setHeaderData(1, Qt::Horizontal, "vend_name");
mode->setHeaderData(2, Qt::Horizontal, "prod_name");
mode->setHeaderData(3, Qt::Horizontal, "prod_price");
*/
QSqlRelationalTableModel * mode =
new QSqlRelationalTableModel;
mode->setTable("products");
QSqlRelation relation("vendors",
"vend_id",
"vend_name");
mode->setRelation(1, relation);
mode->select();
mode->setHeaderData(0, Qt::Horizontal, "prod_id");
mode->setHeaderData(1, Qt::Horizontal, "vend_name");
mode->setHeaderData(2, Qt::Horizontal, "prod_name");
mode->setHeaderData(3, Qt::Horizontal, "prod_price");
QTableView * tableview = new QTableView(&w);
tableview->verticalHeader()->hide();
tableview->setModel(mode);
w.setCentralWidget(tableview);
w.resize(600, 400);
w.show();
return a.exec();
}
bool Board::canMoveMa(int moveid, int, int row, int col)
{
GetRowCol(row1, col1, moveid);
int r = relation(row1, col1, row, col);
// 首先判断马要走马字
if (r != 12 && r != 21) {
return false;
}
// 判断有没有蹩马腿的情况
if (r == 12) { // 列相差等于2
if (getStoneId(row1, (col + col1) / 2) != -1) {
return false;
}
}
else { // 行相差等于2
if (getStoneId((row + row1) / 2, col1) != -1) {
return false;
}
}
return true;
}
