//------------------------------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; }