void PcbXML::drawPad(QDomNode node){ QDomElement element = node.toElement(); QDomElement pad = m_svg->createElement("rect"); // TODO: mask and keepout layers int x1 = qMin(element.attribute("rX1").toInt(),element.attribute("rX2").toInt()) + m_markx; int x2 = qMax(element.attribute("rX1").toInt(),element.attribute("rX2").toInt()) + m_markx; int y1 = qMin(element.attribute("rY1").toInt(),element.attribute("rY2").toInt()) + m_marky; int y2 = qMax(element.attribute("rY1").toInt(),element.attribute("rY2").toInt()) + m_marky; int thickness = element.attribute("Thickness").toInt(); QString id = "connector" + QString::number(m_padCount) + "pad"; m_padCount++; int x = x1 - (thickness/2); int y = y1 - (thickness/2); int width = x2 - x1 + thickness; int height = y2 -y1 + thickness; pad.setAttribute("x", x); pad.setAttribute("y", y); pad.setAttribute("width", width); pad.setAttribute("height", height); pad.setAttribute("fill", "rgb(255, 191, 0)"); pad.setAttribute("id", id); QDomNode temp = m_copper.appendChild(pad); minMax(x,y,0); minMax(x+width,y+height,0); }
TEST_F(MinMaxTests, ThreeEntriesTests) { const int numValues = 3; float floatValues[numValues] = { 22, 7, 52}; float minFloatVal = 7; float maxFloatVal = 52; float floatMin; float floatMax; double doubleValues[numValues] = { -47, -2, -7}; double minDoubleVal = -47; double maxDoubleVal = -2; double doubleMin; double doubleMax; std::sort(floatValues, floatValues + numValues); do { minMax(floatValues[0], floatValues[1], floatValues[2], &floatMin, &floatMax); EXPECT_EQ(minFloatVal, floatMin); EXPECT_EQ(maxFloatVal, floatMax); } while (std::next_permutation(floatValues, floatValues + numValues)); std::sort(doubleValues, doubleValues + numValues); do { minMax(doubleValues[0], doubleValues[1], doubleValues[2], &doubleMin, &doubleMax); EXPECT_EQ(minDoubleVal, doubleMin); EXPECT_EQ(maxDoubleVal, doubleMax); } while (std::next_permutation(doubleValues, doubleValues + numValues)); };
__int64 CHexViewView::getTopLineFromTrackPosition() { SCROLLINFO scrollInfo; GetScrollInfo(SB_VERT,&scrollInfo); if(!m_useScrollBarHelper) { return minMax(scrollInfo.nTrackPos, 0, (int)m_maxTopLine); } else { const DoubleInterval &range = m_scrollBarHelper.getToInterval(); const double trackPos = scrollInfo.nTrackPos; const double line = m_scrollBarHelper.backwardTransform(minMax(trackPos, range.getFrom(), range.getTo())); return (__int64)line; } }
void CHexViewView::showCaret() { if(!m_caretVisible) { CreateSolidCaret(2, CARETHEIGHT); ShowCaret(); m_caretVisible = true; } m_caret.y = minMax(m_caret.y, 0, m_maxCaret.y); m_caret.x = minMax(m_caret.x, 0, m_maxCaret.x); bool redraw = false; if(m_lineCount && (m_lastLineSize < m_lineSize) && (m_topLine + m_caret.y == m_lineCount-1)) { if(m_lineOffset > m_maxLastLineOffset) { m_lineOffset = m_maxLastLineOffset; isNewSelection(); redraw = true; } else { m_caret.x = minMax(m_caret.x, 0, m_lastLineSize - m_lineOffset); redraw = isNewSelection(); } } else { redraw = isNewSelection(); } m_lastCurrentAddr = getCurrentAddr(); m_lastSelection = getSelection(); if(redraw) { repaint(); return; } CPoint p(m_caret.x * m_byteSize.cx + m_contentRect.left + m_digitIndex*m_charSize.cx, m_caret.y * m_byteSize.cy + m_contentRect.top); SetCaretPos(p); m_keepSelection = false; /* const String tmp = format(_T("%s bytes. Addr:%s. Lsize:%d[%d]. Lcount:%I64u, Psize(%d,%d), Scroll(%d,%I64u),max(%d,%I64u)[%d], Caret(%d,%d),max:(%d,%d), Anchor:%I64d, Mark:%s, %s") ,format1000(m_docSize ).cstr() ,format1000(getCurrentAddr()).cstr() ,m_lineSize, m_lastLineSize ,m_lineCount ,m_pageSize.cx, m_pageSize.cy ,m_lineOffset , m_topLine , m_maxLineOffset, m_maxTopLine, m_maxLastLineOffset ,m_caret.x , m_caret.y , m_maxCaret.x , m_maxCaret.y ,m_anchor ,getSelection().toString().cstr() ,m_shift ? _T("shift") : EMPTYSTRING); theApp.GetMainWnd()->SetWindowText(tmp.cstr()); */ }
void BitalinoPacketListener::ProcessMessage( const osc::ReceivedMessage& m ) { try{ if( std::strcmp( m.AddressPattern(), "/wek/inputs" ) == 0 ){ osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin(); float emg = (arg++)->AsFloat(); float emgFilt = (arg++)->AsFloat(); float eda = (arg++)->AsFloat(); this->emgBuffer[this->curEmgBuffIdx++] = emgFilt; if (this->curEmgBuffIdx >= BUFFER_SIZE) { this->curEmgBuffIdx = 0; } this->emgStd = minMax(this->emgBuffer, BUFFER_SIZE); float ecg = (arg++)->AsFloat(); this->accelMean =(arg++)->AsFloat(); this->lux = (arg++)->AsFloat(); //std::cout << "emg: " << emg << " emgfilt: " << emgFilt << " eda: " << eda << " ecg: " << ecg << " accel: " << accel << " lux: " << lux << '\n'; } }catch( osc::Exception& e ){ // any parsing errors such as unexpected argument types, or // missing arguments get thrown as exceptions. std::cout << "error while parsing message: " << m.AddressPattern() << ": " << e.what() << "\n"; } }
void CSliderCtrlWithTransformation::setPos(double pos) { ASSERTCREATED(); const DoubleInterval &iv = m_tr->getFromInterval(); pos = minMax(pos, iv.getFrom(), iv.getTo()); const int p = (int)m_tr->forwardTransform(pos); SetPos(p); }
bool LinePolygonsCrossings::calcScanlineCrossings(bool fail_on_unavoidable_obstacles) { min_crossing_idx = NO_INDEX; max_crossing_idx = NO_INDEX; for(unsigned int poly_idx = 0; poly_idx < boundary.size(); poly_idx++) { PolyCrossings minMax(poly_idx); PolygonRef poly = boundary[poly_idx]; Point p0 = transformation_matrix.apply(poly[poly.size() - 1]); for(unsigned int point_idx = 0; point_idx < poly.size(); point_idx++) { Point p1 = transformation_matrix.apply(poly[point_idx]); if ((p0.Y >= transformed_startPoint.Y && p1.Y <= transformed_startPoint.Y) || (p1.Y >= transformed_startPoint.Y && p0.Y <= transformed_startPoint.Y)) { // if line segment crosses the line through the transformed start and end point (aka scanline) if (p1.Y == p0.Y) //Line segment is parallel with the scanline. That means that both endpoints lie on the scanline, so they will have intersected with the adjacent line. { p0 = p1; continue; } int64_t x = p0.X + (p1.X - p0.X) * (transformed_startPoint.Y - p0.Y) / (p1.Y - p0.Y); // intersection point between line segment and the scanline if (x >= transformed_startPoint.X && x <= transformed_endPoint.X) { if (!((p1.Y == transformed_startPoint.Y && p1.Y < p0.Y) || (p0.Y == transformed_startPoint.Y && p0.Y < p1.Y))) { // perform edge case only for line segments on and below the scanline, not for line segments on and above. // \/ will be no crossings and /\ two, but most importantly | will be one crossing. minMax.n_crossings++; } if(x < minMax.min.x) //For the leftmost intersection, move x left to stay outside of the border. //Note: The actual distance from the intersection to the border is almost always less than dist_to_move_boundary_point_outside, since it only moves along the direction of the scanline. { minMax.min.x = x; minMax.min.point_idx = point_idx; } if(x > minMax.max.x) //For the rightmost intersection, move x right to stay outside of the border. { minMax.max.x = x; minMax.max.point_idx = point_idx; } } } p0 = p1; } if (fail_on_unavoidable_obstacles && minMax.n_crossings % 2 == 1) { // if start area and end area are not the same return false; } else if (minMax.min.point_idx != NO_INDEX) // then always also max.point_idx != NO_INDEX { // if this polygon crossed the scanline if (min_crossing_idx == NO_INDEX || minMax.min.x < crossings[min_crossing_idx].min.x) { min_crossing_idx = crossings.size(); } if (max_crossing_idx == NO_INDEX || minMax.max.x > crossings[max_crossing_idx].max.x) { max_crossing_idx = crossings.size(); } crossings.push_back(minMax); } } return true; }
CHexViewView &CHexViewView::setTopLine(__int64 value, bool invalidate) { m_topLine = minMax(value, 0i64, m_maxTopLine); resetDigitIndex(); if(invalidate) { repaint(); } return *this; }
CHexViewView &CHexViewView::setLineOffset(int value, bool invalidate) { m_lineOffset = minMax(value, 0, m_maxLineOffset); resetDigitIndex(); if(invalidate) { repaint(); } return *this; }
int main(int argc, const char * argv[]) { short min, max; short a[] = {1, 4, 5, 78, -100, 45, 28, 34, 5}; minMax(a, 9, &min, &max); printf("min:%d max:%d\n", min, max); return 0; }
void PcbXML::drawPin(QDomNode node){ QDomElement element = node.toElement(); QDomElement pin = m_svg->createElement("circle"); int x; int y; if( element.hasAttribute("aX") ){ x = element.attribute("aX").toInt(); y = element.attribute("aY").toInt(); } else { x = element.attribute("rX").toInt() + m_markx; y = element.attribute("rY").toInt() + m_marky; } int drill = element.attribute("Drill").toInt()/2; int thickness = element.attribute("Thickness").toInt()/2 - drill; int radius = drill + thickness/2; QString id = QString("connector%1pin").arg(m_pinCount); // BUG: what's up with str -> hex conversion??? bool verify; bool square=false; if(element.hasAttribute("NFlags")) { square = element.attribute("NFlags").toInt(&verify,16) & 0x0100; } else if(element.hasAttribute("SFlags")) { square = element.attribute("SFlags").toInt(&verify,16) & 0x0100; } //DebugDialog::debug(QString("NFlags: %1 Value:%2 Square:%3").arg(element.attribute("NFlags")).arg(element.attribute("NFlags").toInt(&verify,16)).arg(square)); m_pinCount++; if(square){ QDomElement sq = m_svg->createElement("rect"); sq.setAttribute("x",x-radius); sq.setAttribute("y",y-radius); sq.setAttribute("fill", "none"); sq.setAttribute("width",radius*2); sq.setAttribute("height",radius*2); sq.setAttribute("stroke", "rgb(255, 191, 0)"); sq.setAttribute("stroke-width", thickness); QDomNode tempsq = m_copper.appendChild(sq); } pin.setAttribute("cx", x); pin.setAttribute("cy", y); pin.setAttribute("r", radius); pin.setAttribute("stroke", "rgb(255, 191, 0)"); pin.setAttribute("stroke-width", thickness); pin.setAttribute("id", id); pin.setAttribute("fill", "none"); QDomNode temp = m_copper.appendChild(pin); minMax(x,y,radius+(thickness/2)); }
void main(void) { min=0; max=0; int a[] = {100, -100, 200, -200, 500, -500, 400, -400, 300, -300}; minMax(a, 10); //for(;;) {} /* wait forever */ printf("min=%d\n", min); printf("max=%d", max); }
void PcbXML::drawElementLine(QDomNode node){ QDomElement element = node.toElement(); QDomElement line = m_svg->createElement("line"); int x1 = element.attribute("X1").toInt() + m_markx; int y1 = element.attribute("Y1").toInt() + m_marky; int x2 = element.attribute("X2").toInt() + m_markx; int y2 = element.attribute("Y2").toInt() + m_marky; int thickness = element.attribute("Thickness").toInt(); line.setAttribute("x1", x1); line.setAttribute("y1", y1); line.setAttribute("x2", x2); line.setAttribute("y2", y2); line.setAttribute("stroke", "white"); line.setAttribute("stroke-width", thickness); QDomNode temp = m_silkscreen.appendChild(line); minMax(x1,y1,thickness); minMax(x2,y2,thickness); }
BigReal ©(BigReal &to, const BigReal &from, size_t length) { if(!from._isnormal()) { to.clearDigits(); to.copyFields(from); } else { length = minMax(length, (size_t)1, from.getLength()); to.m_low = (to.m_expo = from.m_expo) - length + 1; to.m_negative = from.m_negative; to.clearDigits(); to.copyDigits(from, length); to.trimZeroes(); } return to; }
void LinePolygonsCrossings::calcScanlineCrossings() { min_crossing_idx = NO_INDEX; max_crossing_idx = NO_INDEX; for(unsigned int poly_idx = 0; poly_idx < boundary.size(); poly_idx++) { PolyCrossings minMax(poly_idx); PolygonRef poly = boundary[poly_idx]; Point p0 = transformation_matrix.apply(poly[poly.size() - 1]); for(unsigned int point_idx = 0; point_idx < poly.size(); point_idx++) { Point p1 = transformation_matrix.apply(poly[point_idx]); if((p0.Y >= transformed_startPoint.Y && p1.Y <= transformed_startPoint.Y) || (p1.Y >= transformed_startPoint.Y && p0.Y <= transformed_startPoint.Y)) { if(p1.Y == p0.Y) //Line segment is parallel with the scanline. That means that both endpoints lie on the scanline, so they will have intersected with the adjacent line. { p0 = p1; continue; } int64_t x = p0.X + (p1.X - p0.X) * (transformed_startPoint.Y - p0.Y) / (p1.Y - p0.Y); if (x >= transformed_startPoint.X && x <= transformed_endPoint.X) { if(x < minMax.min.x) //For the leftmost intersection, move x left to stay outside of the border. //Note: The actual distance from the intersection to the border is almost always less than dist_to_move_boundary_point_outside, since it only moves along the direction of the scanline. { minMax.min.x = x; minMax.min.point_idx = point_idx; } if(x > minMax.max.x) //For the rightmost intersection, move x right to stay outside of the border. { minMax.max.x = x; minMax.max.point_idx = point_idx; } } } p0 = p1; } if (minMax.min.point_idx != NO_INDEX) { // then also max.point_idx != -1 if (min_crossing_idx == NO_INDEX || minMax.min.x < crossings[min_crossing_idx].min.x) { min_crossing_idx = crossings.size(); } if (max_crossing_idx == NO_INDEX || minMax.max.x > crossings[max_crossing_idx].max.x) { max_crossing_idx = crossings.size(); } crossings.push_back(minMax); } } }
//Handles compureter move void Game::aiMove() { bool movemade = false; while (!movemade) { int i = minMax(); setCell(i, currentPlayer); //int index = (rand() % 9); //if (gridRows[index] == GRID_TYPE_NONE) { // gridRows[index] = currentPlayer; movemade = true; //} } currentPlayer = 2; };
int AI::launchAI(const int tab[19][19], const t_flag& team, const int& pionOne, const int& pionTwo) { int toRet; for (int y = 0; y != 19; y++) { for (int x = 0; x != 19; x++) { _mapRule[y][x] = tab[y][x]; } } _nbPionOne = pionOne; _nbPionTwo = pionTwo; _initTeam = team; toRet = minMax(team); std::cout << MAGENTA << "[IA] Value ask : " << toRet << END << std::endl; return toRet; }
int main() { int n,a[MAXSIZE],ans[2], i; printf("\nEnter the no of elements "); scanf("%d",&n); for(i=1;i<=n;i++) scanf("%d",&a[i]); minMax(n,a,ans); printf("\nMinimum is %d \nMaximum is %d\n",ans[0],ans[1]); return 0; }
void CZoomDlg::scrollHorizontal(int n) { CEdit *e = (CEdit*)GetDlgItem(IDC_EDIT2LINES); LOGFONT lf; m_font.GetLogFont(&lf); SCROLLINFO info; info.cbSize = sizeof(info); e->GetScrollInfo(SB_HORZ, &info); const int newPos = minMax(info.nPos + n, info.nMin, info.nMax); const int amount = newPos - info.nPos; if(amount != 0) { e->SetScrollPos(SB_HORZ, newPos); e->ScrollWindow(-amount,0); UpdateWindow(); } }
void DRunningEnemy::Moving(float updateTime) { for(int i = 0; i < numOfEnemies; i++) { runners.at(i)->MoveX(-speed[i] * updateTime); minMax(runners[i], i); playerCollision = PlayerCollisionDetection(i); if(runners.at(i)->GetX() < player->GetX()-200) { runners.at(i)->SetX(player->GetX()+400); } else if(playerCollision == true) { runners.at(i)->SetX(player->GetX()+400); } } }
unsigned int Heuristic::bestMove(board* b, int color) { int iterativeMaxLevel = ARRAY_SIZE; // max level for iterative deepening search this->b = b; this->color = color; unsigned long long upArray[ARRAY_SIZE]; memset(upArray,0,sizeof(unsigned long long)*ARRAY_SIZE); int sum=0; timeoutMove = 0; //maxLevel = 4; iteration = 0; counter = 0; firstMove = false; for(int i=0; i<ARRAY_SIZE; ++i) { bestLeafPath[i] = 0; } b->calculatePossibleMoves(color); if (b->getPossibleMoves(color).size() == 1) return *(b->getPossibleMoves(color).begin()); for (maxLevel=1; maxLevel <= iterativeMaxLevel; ++maxLevel) { memset(upArray,0,sizeof(unsigned long long)*ARRAY_SIZE); // filling array with 0 iteration = 0; minMax(0, MINUS_INFINITY, PLUS_INFINITY, upArray); for (int i=0; i<ARRAY_SIZE; ++i) { // copy best move found in last minMax bestLeafPath[i] = upArray[i]; } std::cout<<"-> Level " << maxLevel<< " at " << iteration<< " iterations" << std::endl; sum += iteration; firstMove = true; } std::cout<<std::endl<<"sum: "<<sum<<std::endl; if (timeoutMove > 0 ) { // timeout occurred, get last best value return timeoutMove; } return actualMove; }
void LinePolygonsCrossings::calcScanlineCrossings() { min_crossing_idx = NO_INDEX; max_crossing_idx = NO_INDEX; for(unsigned int poly_idx = 0; poly_idx < boundary.size(); poly_idx++) { PolyCrossings minMax(poly_idx); PolygonRef poly = boundary[poly_idx]; Point p0 = transformation_matrix.apply(poly.back()); for(unsigned int point_idx = 0; point_idx < poly.size(); point_idx++) { Point p1 = transformation_matrix.apply(poly[point_idx]); if ((p0.Y > transformed_startPoint.Y && p1.Y < transformed_startPoint.Y) || (p1.Y > transformed_startPoint.Y && p0.Y < transformed_startPoint.Y)) { int64_t x = p0.X + (p1.X - p0.X) * (transformed_startPoint.Y - p0.Y) / (p1.Y - p0.Y); if (x >= transformed_startPoint.X && x <= transformed_endPoint.X) { if (x < minMax.min.x) { minMax.min.x = x; minMax.min.point_idx = point_idx; } if (x > minMax.max.x) { minMax.max.x = x; minMax.max.point_idx = point_idx; } } } p0 = p1; } if (minMax.min.point_idx != NO_INDEX) { // then also max.point_idx != -1 if (min_crossing_idx == NO_INDEX || minMax.min.x < crossings[min_crossing_idx].min.x) { min_crossing_idx = crossings.size(); } if (max_crossing_idx == NO_INDEX || minMax.max.x > crossings[max_crossing_idx].max.x) { max_crossing_idx = crossings.size(); } crossings.push_back(minMax); } } }
Point AIPlayer::move(const GameField &gameField, const Player &opponent) { int row = -1; int column = -1; int fieldSize = gameField.getSize(); Point point(-1, -1); if (gameField.getSize() > 3) { do { row = -1; column = -1; while (row < 0 || row > fieldSize - 1) { row = rand() % fieldSize; } while (column < 0 || row > fieldSize - 1) { column = rand() % fieldSize; } } while (gameField.getField(row, column) != GameField::M_EMPTY_CHAR); point = Point(row, column); } else { MinMax minMax(*this, opponent); minMax.minMax(gameField, *this, opponent, 0); point = minMax.getBestMove(); mLastMove = point; } return point; }
/* Combines min and max into one function that always does max */ double minMax(State *currBoard, int depth) { State nextBoard; double rval; int i; double maxv=-100000.0; if(depth <= 0) return evalBoard2(currBoard); FindLegalMoves(currBoard); for(i=0; i<currBoard->numLegalMoves; i++) { /* Set up the next state by copying the current state and then updating the new */ /* state to reflect the new board after performing the move */ memcpy (&nextBoard, currBoard, sizeof(State)); PerformMove(nextBoard.board,currBoard->movelist[i],MoveLength(currBoard->movelist[i])); nextBoard.player = 3-nextBoard.player; rval = -minMax(&nextBoard, depth-1); if (rval > maxv) maxv = rval; } return maxv; }
TEST_F(MinMaxTests, AribtraryEntriesTests) { const int numValues = 5; float floatValues[numValues] = { 18, 7, 52, 12, 12}; float minFloatVal = 7; float maxFloatVal = 52; float floatMin; float floatMax; double doubleValues[numValues] = { -23, -47, -2, -17, -17}; double minDoubleVal = -47; double maxDoubleVal = -2; double doubleMin; double doubleMax; ASSERT_THROW(minMax(floatValues, 0, &floatMin, &floatMax), SurgSim::Framework::AssertionFailure); ASSERT_THROW(minMax(floatValues, -1, &floatMin, &floatMax), SurgSim::Framework::AssertionFailure); std::sort(floatValues, floatValues + numValues); do { minMax(floatValues, numValues, &floatMin, &floatMax); EXPECT_EQ(minFloatVal, floatMin); EXPECT_EQ(maxFloatVal, floatMax); } while (std::next_permutation(floatValues, floatValues + numValues)); ASSERT_THROW(minMax(doubleValues, 0, &doubleMin, &doubleMax), SurgSim::Framework::AssertionFailure); ASSERT_THROW(minMax(doubleValues, -1, &doubleMin, &doubleMax), SurgSim::Framework::AssertionFailure); std::sort(doubleValues, doubleValues + numValues); do { minMax(doubleValues, numValues, &doubleMin, &doubleMax); EXPECT_EQ(minDoubleVal, doubleMin); EXPECT_EQ(maxDoubleVal, doubleMax); } while (std::next_permutation(doubleValues, doubleValues + numValues)); };
void QgsGrassVectorMapLayer::load() { clear(); if ( !mMap ) { return; } // Attributes are not loaded for topo layers in which case field == 0 if ( mField == 0 ) { return; } QgsDebugMsg( QString( "cidxFieldIndex() = %1 cidxFieldNumCats() = %2" ).arg( cidxFieldIndex() ).arg( cidxFieldNumCats() ) ); mFieldInfo = Vect_get_field( mMap->map(), mField ); // should work also with field = 0 if ( !mFieldInfo ) { QgsDebugMsg( "No field info -> no attribute table" ); } else { QgsDebugMsg( "Field info found -> open database" ); QFileInfo di( mMap->grassObject().mapsetPath() + "/vector/" + mMap->grassObject().name() + "/dbln" ); mLastLoaded = di.lastModified(); QString error; dbDriver *databaseDriver = openDriver( error ); if ( !databaseDriver || !error.isEmpty() ) { QgsDebugMsg( error ); } else { QgsDebugMsg( "Database opened -> open select cursor" ); QgsGrass::lock(); // not sure if lock is necessary dbString dbstr; db_init_string( &dbstr ); db_set_string( &dbstr, ( char * )"select * from " ); db_append_string( &dbstr, mFieldInfo->table ); QgsDebugMsg( QString( "SQL: %1" ).arg( db_get_string( &dbstr ) ) ); dbCursor databaseCursor; if ( db_open_select_cursor( databaseDriver, &dbstr, &databaseCursor, DB_SCROLL ) != DB_OK ) { db_close_database_shutdown_driver( databaseDriver ); QgsGrass::warning( "Cannot select attributes from table '" + QString( mFieldInfo->table ) + "'" ); } else { #ifdef QGISDEBUG int nRecords = db_get_num_rows( &databaseCursor ); QgsDebugMsg( QString( "Number of records: %1" ).arg( nRecords ) ); #endif dbTable *databaseTable = db_get_cursor_table( &databaseCursor ); int nColumns = db_get_table_number_of_columns( databaseTable ); // Read columns' description for ( int i = 0; i < nColumns; i++ ) { QPair<double, double> minMax( DBL_MAX, -DBL_MAX ); dbColumn *column = db_get_table_column( databaseTable, i ); int ctype = db_sqltype_to_Ctype( db_get_column_sqltype( column ) ); QVariant::Type qtype = QVariant::String; //default to string QgsDebugMsg( QString( "column = %1 ctype = %2" ).arg( db_get_column_name( column ) ).arg( ctype ) ); QString ctypeStr; switch ( ctype ) { case DB_C_TYPE_INT: ctypeStr = QStringLiteral( "integer" ); qtype = QVariant::Int; break; case DB_C_TYPE_DOUBLE: ctypeStr = QStringLiteral( "double" ); qtype = QVariant::Double; break; case DB_C_TYPE_STRING: ctypeStr = QStringLiteral( "string" ); qtype = QVariant::String; break; case DB_C_TYPE_DATETIME: ctypeStr = QStringLiteral( "datetime" ); qtype = QVariant::String; break; } mTableFields.append( QgsField( db_get_column_name( column ), qtype, ctypeStr, db_get_column_length( column ), db_get_column_precision( column ) ) ); mMinMax << minMax; if ( G_strcasecmp( db_get_column_name( column ), mFieldInfo->key ) == 0 ) { mKeyColumn = i; } } if ( mKeyColumn < 0 ) { mTableFields.clear(); QgsGrass::warning( QObject::tr( "Key column '%1' not found in the table '%2'" ).arg( mFieldInfo->key, mFieldInfo->table ) ); } else { mHasTable = true; // Read attributes to the memory for ( ;; ) { int more; if ( db_fetch( &databaseCursor, DB_NEXT, &more ) != DB_OK ) { QgsDebugMsg( "Cannot fetch DB record" ); break; } if ( !more ) { break; // no more records } // Check cat value dbColumn *column = db_get_table_column( databaseTable, mKeyColumn ); dbValue *value = db_get_column_value( column ); if ( db_test_value_isnull( value ) ) { continue; } int cat = db_get_value_int( value ); if ( cat < 0 ) { continue; } QList<QVariant> values; for ( int i = 0; i < nColumns; i++ ) { column = db_get_table_column( databaseTable, i ); int sqltype = db_get_column_sqltype( column ); int ctype = db_sqltype_to_Ctype( sqltype ); value = db_get_column_value( column ); db_convert_value_to_string( value, sqltype, &dbstr ); QgsDebugMsgLevel( QString( "column = %1 value = %2" ).arg( db_get_column_name( column ), db_get_string( &dbstr ) ), 3 ); QVariant variant; if ( !db_test_value_isnull( value ) ) { int iv; double dv; //layer.mAttributes[layer.nAttributes].values[i] = strdup( db_get_string( &dbstr ) ); switch ( ctype ) { case DB_C_TYPE_INT: iv = db_get_value_int( value ); variant = QVariant( iv ); mMinMax[i].first = std::min( mMinMax[i].first, ( double )iv ); mMinMax[i].second = std::min( mMinMax[i].second, ( double )iv ); break; case DB_C_TYPE_DOUBLE: dv = db_get_value_double( value ); variant = QVariant( dv ); mMinMax[i].first = std::min( mMinMax[i].first, dv ); mMinMax[i].second = std::min( mMinMax[i].second, dv ); break; case DB_C_TYPE_STRING: // Store as byte array so that codec may be used later variant = QVariant( QByteArray( db_get_value_string( value ) ) ); break; case DB_C_TYPE_DATETIME: variant = QVariant( QByteArray( db_get_string( &dbstr ) ) ); break; default: variant = QVariant( QByteArray( db_get_string( &dbstr ) ) ); } } QgsDebugMsgLevel( QString( "column = %1 variant = %2" ).arg( db_get_column_name( column ), variant.toString() ), 3 ); values << variant; } mAttributes.insert( cat, values ); } } mValid = true; db_close_cursor( &databaseCursor ); db_close_database_shutdown_driver( databaseDriver ); db_free_string( &dbstr ); QgsDebugMsg( QString( "mTableFields.size = %1" ).arg( mTableFields.size() ) ); QgsDebugMsg( QString( "number of attributes = %1" ).arg( mAttributes.size() ) ); } QgsGrass::unlock(); } } // Add cat if no attribute fields exist (otherwise qgis crashes) if ( mTableFields.size() == 0 ) { mKeyColumn = 0; mTableFields.append( QgsField( QStringLiteral( "cat" ), QVariant::Int, QStringLiteral( "integer" ) ) ); QPair<double, double> minMax( 0, 0 ); if ( cidxFieldIndex() >= 0 ) { int ncats, cat, type, id; ncats = Vect_cidx_get_num_cats_by_index( mMap->map(), cidxFieldIndex() ); if ( ncats > 0 ) { Vect_cidx_get_cat_by_index( mMap->map(), cidxFieldIndex(), 0, &cat, &type, &id ); minMax.first = cat; Vect_cidx_get_cat_by_index( mMap->map(), cidxFieldIndex(), ncats - 1, &cat, &type, &id ); minMax.second = cat; } } mMinMax << minMax; } mFields = mTableFields; mAttributeFields = mTableFields; QgsDebugMsg( QString( "layer loaded mTableFields.size() = %1 mAttributes.size() = %2" ).arg( mTableFields.size() ).arg( mAttributes.size() ) ); mValid = true; }
int Heuristic::minMax(int level, int alpha, int beta, unsigned long long downArray[]) { int tmp = 0; // temporary value which is compared to max value int winCheck=0; set<unsigned long long int> tempMoveSet; set<unsigned long long int>::iterator iter, iterEnd, iterTmp; if (!aiPlayer->working) { // if timeout! return 0; // value doesn't matter } winCheck = b->terminal(); if (winCheck == color+2) // computer wins return PLUS_INFINITY / level; if (winCheck == 1) // draw return 0; if (winCheck != 0) // opponent wins return MINUS_INFINITY; // Leaf if (level == maxLevel) { iteration++; return evaluation(); } // MAX if (level % 2 == 0) { // getting possible moves b->calculatePossibleMoves(color); tempMoveSet = b->getPossibleMoves(color); if (firstMove) { if (level == maxLevel-2) { // in next minMax call start exploring tree without first move path firstMove = false; } tempMoveSet.erase(bestLeafPath[level]); // delete best move from the set // copied part from above b->movePiece(bestLeafPath[level], color); // do the best move unsigned long long * upArray; // array given to upper minMax call upArray = new unsigned long long [ARRAY_SIZE]; memset(upArray,0,sizeof(unsigned long long)*ARRAY_SIZE); // cleaning array with 0 tmp = minMax(level+1, alpha, beta, upArray); b->undoMove(); b->clean(); b->calculatePossibleMoves(color); if (tmp > alpha) { alpha = tmp; downArray[level] = bestLeafPath[level]; // store best move so far (at current level) for(int i = level+1; i<maxLevel; ++i) { // copy good moves from higher levels downArray[i] = upArray[i]; } if (level == 0) { actualMoveMutex.acquire(); actualMove = bestLeafPath[level]; actualMoveMutex.release(); } } delete[] upArray; } iter = tempMoveSet.begin(); iterEnd = tempMoveSet.end(); for (; iter != iterEnd; ++iter) { if (alpha >= beta) // while (alpha < beta) break; b->movePiece(*iter, color); unsigned long long * upArray; // array given to upper minMax call upArray = new unsigned long long [ARRAY_SIZE]; memset(upArray,0,sizeof(unsigned long long)*ARRAY_SIZE); // cleaning array with 0 tmp = minMax(level+1, alpha, beta, upArray); b->undoMove(); b->clean(); b->calculatePossibleMoves(color); if (tmp > alpha) { alpha = tmp; downArray[level] = *iter; // store best move so far (at current level) for(int i = level+1; i<maxLevel; ++i) { // copy good moves from higher levels downArray[i] = upArray[i]; } if (level == 0) { actualMoveMutex.acquire(); actualMove = *iter; actualMoveMutex.release(); } } delete[] upArray; } return alpha; } // MIN else { // getting possible moves b->calculatePossibleMoves(!color); tempMoveSet = b->getPossibleMoves(!color); if (firstMove) { if (level == maxLevel-2) { // in next minMax call start exploring tree without first move path firstMove = false; } tempMoveSet.erase(bestLeafPath[level]); // delete best move from the set // copied part from above b->movePiece(bestLeafPath[level], !color); // do the best move unsigned long long * upArray; // array given to upper minMax call upArray = new unsigned long long [ARRAY_SIZE]; memset(upArray,0,sizeof(unsigned long long)*ARRAY_SIZE); // cleaning array with 0 tmp = minMax(level+1, alpha, beta, upArray); b->undoMove(); b->clean(); b->calculatePossibleMoves(!color); if (tmp < beta) { beta = tmp; downArray[level] = bestLeafPath[level]; // store best move so far (at current level) for(int i = level+1; i<maxLevel; ++i) { // copy good moves from higher levels downArray[i] = upArray[i]; } } delete[] upArray; } iter = tempMoveSet.begin(); iterEnd = tempMoveSet.end(); for (; iter != iterEnd; ++iter) { if (alpha >= beta) // while (alpha < beta) break; b->movePiece(*iter, !color); unsigned long long * upArray; // array given to upper minMax call upArray = new unsigned long long [ARRAY_SIZE]; memset(upArray,0,sizeof(unsigned long long)*ARRAY_SIZE); // cleaning array with 0 tmp = minMax(level+1, alpha, beta, upArray); b->undoMove(); b->clean(); b->calculatePossibleMoves(!color); if (tmp < beta) { beta = tmp; downArray[level] = *iter; // store best move so far (at current level) for(int i = level+1; i<maxLevel; ++i) { // copy good moves from higher levels downArray[i] = upArray[i]; } } delete[] upArray; } return beta; } }
CRect CHexViewView::updateSettings(CDC *dc) { CRect cr; GetClientRect(&cr); CFont *oldFont = NULL; if(dc == NULL) { dc = &m_workDC; oldFont = dc->SelectObject(&m_font); } m_readOnly = GetDocument()->isReadOnly(); m_radixFormat = m_settings->getRadixFormat(); m_asciiFormat = m_settings->getAsciiFormat(); m_byteSize = dc->GetTextExtent(m_settings->getDataSampleText()); m_charSize = dc->GetTextExtent(_T("0")); m_docSize = GetDocument()->getSize(); m_addrFormat.update(m_docSize, *m_settings); const bool showAddr = m_settings->getShowAddr(); const bool showAscii = m_settings->getShowAscii(); if(showAddr) { const String sampleText = m_addrFormat.getSampleText(); m_addrTextSize = getTextExtent(*dc,sampleText); } else { m_addrTextSize = CSize(0,0); } m_contentRect.left = m_addrTextSize.cx; m_contentRect.right = cr.right - m_byteSize.cx; m_contentRect.top = m_addrTextSize.cy; m_contentRect.bottom = cr.bottom - m_byteSize.cy; m_pageSize = CSize((m_contentRect.Width()-4) / m_byteSize.cx + 1, m_contentRect.Height()/m_byteSize.cy); if(m_settings->getFitLinesToWindow()) { m_lineSize = m_contentRect.Width()/m_byteSize.cx + 1; // Use windowsize to determine the number of bytes on each line } else { m_lineSize = m_settings->getLineSize(); } m_lineSize = max(m_lineSize, 1); // just to prevent division by zero. see below m_maxLineOffset = max(m_lineSize - m_pageSize.cx, 0); m_lineOffset = min(m_lineOffset, m_maxLineOffset); m_lineCount = (m_docSize - 1)/m_lineSize + 1; m_maxTopLine = max(m_lineCount - m_pageSize.cy, 0); m_topLine = min(m_topLine, m_maxTopLine); m_maxCaret = CPoint(m_pageSize.cx, m_pageSize.cy - 1); m_maxCaret.x = minMax(m_maxCaret.x, 0, (int)min(m_docSize, m_lineSize)); if(m_maxCaret.y >= m_lineCount) { m_maxCaret.y = (int)m_lineCount - 1; } if (m_maxCaret.y < 0) { m_maxCaret.y = 0; } m_lastLineSize = m_docSize % m_lineSize; if(m_lastLineSize == 0) { m_lastLineSize = m_lineSize; } m_maxLastLineOffset = min(m_lastLineSize - 1, m_maxLineOffset); if(m_readOnly || m_settings->getShowAscii()) { // readonly or ascii => only 0 is valid m_minDigitIndex = m_maxDigitIndex = 0; } else if((m_settings->getDataRadix() != 16)) { // dec or oct => [0..2] m_minDigitIndex = 0; m_maxDigitIndex = 2; } else if(m_settings->getHex3Pos()) { // hex 3-pos => [1..2] m_minDigitIndex = 1; m_maxDigitIndex = 2; } else { // hex 2-pos => [0..1] m_minDigitIndex = 0; m_maxDigitIndex = 1; } m_digitIndex = minMax(m_digitIndex, m_minDigitIndex, m_maxDigitIndex); if(dc == &m_workDC) { dc->SelectObject(oldFont); } return cr; }
void CMakeAviDlg::scrollLines(int count) { const int index = getSelectedIndex() + count; setSelectedIndex(m_nameList, minMax(index, 0, (int)m_nameArray.size())); }
CHexViewView &CHexViewView::setDigitIndex(char index) { m_digitIndex = minMax(index, m_minDigitIndex, m_maxDigitIndex); return *this; }