//! Determine the value corresponding to a specified point
double QwtWheel::getValue( const QPoint &p )
{
// The reference position is arbitrary, but the
// sign of the offset is important
int w, dx;
if ( orientation() == Qt::Vertical )
{
w = d_data->sliderRect.height();
dx = d_data->sliderRect.y() - p.y();
}
else
{
w = d_data->sliderRect.width();
dx = p.x() - d_data->sliderRect.x();
}
// w pixels is an arc of viewAngle degrees,
// so we convert change in pixels to change in angle
const double ang = dx * d_data->viewAngle / w;
// value range maps to totalAngle degrees,
// so convert the change in angle to a change in value
const double val = ang * ( maxValue() - minValue() ) / d_data->totalAngle;
// Note, range clamping and rasterizing to step is automatically
// handled by QwtAbstractSlider, so we simply return the change in value
return val;
}
void QmitkNumberPropertySlider::adjustFactors(short newDecimalPlaces, bool newShowPercents)
{
int oldMax = maxValue();
int oldMin = minValue();
m_DecimalPlaces = newDecimalPlaces;
m_ShowPercents = newShowPercents;
m_FactorPropertyToSlider = pow(10.0,m_DecimalPlaces);
m_FactorSliderToDisplay = 1.0 / m_FactorPropertyToSlider;
// commented line would set the default increase/decrease to 1.0, no matter how many decimal places are available
//setLineStep( ROUND(m_FactorPropertyToSlider) );
if ( m_ShowPercents )
{
m_FactorPropertyToSlider *= 100.0;
//setLineStep( ROUND(0.01 *m_FactorPropertyToSlider) );
//setSuffix("%");
}
else
{
//setSuffix("");
}
setMinimum(oldMin);
setMaximum(oldMax);
}
void QRangeControl::addLine()
{
if ( value() + lineStep() > value() )
setValue( value() + lineStep() );
else
setValue( maxValue() );
}
//方法二：从根处搜索，不需要父指针，时间复杂度：O(h)；
TreeNode * inOrderPredecessor1(TreeNode *root, TreeNode *node)
{
if (!root)
{
return NULL;
}
if (node->left)
{
return maxValue(node->left);
}
TreeNode *succ=NULL;
while (root)
{
if (node->val>root->val)
{
succ=root;
root=root->right;
}
else if (node->val<root->val)
{
root=root->left;
}
else break;
}
return succ;
}
size_t AveragingAllocationStrategy::operator()(const size_t curBufferSize,
const size_t increaseAmt)
{
// The amount of memory to allocate is the larger of the requested size and
// the average size computed from previous allocations.
const size_t alloc_size(maxValue(curBufferSize + increaseAmt,
computeAverage()));
// Record the current amount allocated for future computations of the
// average allocation amount. We accomplish this by first populating
// mAllocSizes until its size equals mWindowSize. After that, we just
// assign to the entry identified by mIndex.
if ( mAllocSizes.size() < mWindowSize )
{
mAllocSizes.push_back(alloc_size);
}
else
{
mAllocSizes[mIndex] = alloc_size;
}
mIndex = (mIndex + 1) % mWindowSize;
return alloc_size;
}
/*!
Sets the minimum value of the range to \a minVal.
If necessary, the maxValue() is adjusted so that the range remains
valid.
\sa minValue() setMaxValue()
*/
void QRangeControl::setMinValue( int minVal )
{
int maxVal = maxValue();
if ( maxVal < minVal )
maxVal = minVal;
setRange( minVal, maxVal );
}
int AgentAB::minValue(int depth, int alpha, int beta) {
//returns a value and an action in vector<int> ansMove
//within the depth limit
if (depth == 0)
return eval(searchState_);
int v = INT_MAX;
vector<vector<int> >moveList = searchState_.successor(MIN);
vector<vector<int> >::iterator iter;
vector<int> tmpPos;
for (iter = moveList.begin(); iter != moveList.end(); iter++) {
tmpPos = searchState_.minPos;
searchState_.update(MIN, *iter);
int tmp = maxValue(depth - 1, alpha, beta);
searchState_.moveBack(MIN, tmpPos);
if (v > tmp) {
v = tmp;
if (depth == depthLimit)
ansMove = (*iter);
}
if (v <= alpha)
return v;
beta = min(v, beta);
}
return v;
}
void QRangeControl::addPage()
{
if ( value() + pageStep() > value() )
setValue( value() + pageStep() );
else
setValue( maxValue() );
}
//==============================================================================
value_type MoveSelector::minValue(
const BitBoardPtr &spBoard,
const value_type &depth,
value_type alpha,
value_type beta
) const
{
ValidMoveSet vms(m_wpMoveSet, spBoard);
value_type score = m_evaluator.Score(spBoard, vms);
if (reachedEndState(depth, score))
{
return score;
}
MoveList moves = vms.GetMyValidMoves();
value_type v = s_posInfinity;
for (auto it = moves.begin(); it != moves.end(); ++it)
{
BitBoardPtr spResult = result(spBoard, *it);
v = std::min(v, maxValue(spResult, depth-1, alpha, beta));
if (score <= alpha)
{
return v;
}
beta = std::min(beta, v);
}
return v;
}
void SliderBase::wheelEvent(QWheelEvent *e)
{
if(_ignoreMouseWheel)
{
e->ignore();
return;
}
e->accept();
float inc = (maxValue() - minValue()) / 40;
if (e->modifiers() == Qt::ShiftModifier)
inc = inc / 10;
if (inc < step())
inc = step();
if (e->delta() > 0)
setValue(value() + inc);
else
setValue(value() - inc);
emit sliderMoved(value(), _id);
emit sliderMoved((int)value(), _id);
}
/**
* [isBST description]
* @param node [description]
* @return [description]
*/
int isBST(struct node* node)
{
if(node == NULL)
{
return 1;
}
else
{
if((node->left != NULL) && (minValue(node->left) > node->data))
{
return 0;
}
if((node->right != NULL) && (maxValue(node->right) <= node->data))
{
return 0;
}
if(!isBST(node->left) || !isBST(node->right))
{
return 0;
}
return 1;
}
}
void KDoubleSpinBox::setLineStep( double step ) {
bool ok = false;
if ( step > maxValue() - minValue() )
base::setLineStep( 1 );
else
base::setLineStep( kMax( d->mapToInt( step, &ok ), 1 ) );
}
int main(void){
int m,n;
while(scanf("%d %d",&m,&n)!=EOF&&0<m&&m<=1000&&0<n&&n<=1000){
int **arr=(int **)malloc(m*sizeof(int *));
if(arr==NULL){
printf("malloc fail\n");
return -1;
}
//输入数据
int i=0;
for(;i<m;i++){
arr[i]=(int *)malloc(n*sizeof(int));
if(arr[i]==NULL){
printf("malloc fail\n");
return -1;
}
int j=0;
for(;j<n;j++){
scanf("%d",&arr[i][j]);
}
}
int res=maxValue(arr,m,n);
printf("%d\n",res);
}
return 0;
}
int maxIndex(int arr[], int size)
{
int i;
int o = maxValue(arr, size);
for (i = 0; i < size; i++)
if (arr[i] == o)
return i;
}
/*!
\brief Notify a change of the range
Called by QwtAbstractSlider
*/
void QwtKnob::rangeChange()
{
if ( autoScale() )
rescale( minValue(), maxValue() );
layoutKnob( true );
recalcAngle();
}
void KDoubleNumInput::updateLegacyMembers() {
// ### update legacy members that are either not private or for
// which an inlined getter exists:
m_lower = minValue();
m_upper = maxValue();
m_step = d->spin->lineStep();
m_specialvalue = specialValueText();
}
double LpaStar::calc_H(int x, int y) {
int diffY = abs(goal->y - y);
int diffX = abs(goal->x - x);
//maze[y][x].h = (double)maxValue(diffY, diffX);
return (double)maxValue(diffY, diffX);
}
int main(int argc, char const *argv[])
{
printf("请输入三个数，求最大值：\n");
int a,b,c;
scanf("%d,%d,%d",&a,&b,&c);
printf("最大值：%d\n",maxValue(a,b,c));
return 0;
}
int QwtThermo::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: setValue((*reinterpret_cast< double(*)>(_a[1]))); break;
default: ;
}
_id -= 1;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< bool*>(_v) = alarmEnabled(); break;
case 1: *reinterpret_cast< double*>(_v) = alarmLevel(); break;
case 2: *reinterpret_cast< ScalePos*>(_v) = scalePosition(); break;
case 3: *reinterpret_cast< int*>(_v) = spacing(); break;
case 4: *reinterpret_cast< int*>(_v) = borderWidth(); break;
case 5: *reinterpret_cast< double*>(_v) = maxValue(); break;
case 6: *reinterpret_cast< double*>(_v) = minValue(); break;
case 7: *reinterpret_cast< int*>(_v) = pipeWidth(); break;
case 8: *reinterpret_cast< double*>(_v) = value(); break;
}
_id -= 9;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setAlarmEnabled(*reinterpret_cast< bool*>(_v)); break;
case 1: setAlarmLevel(*reinterpret_cast< double*>(_v)); break;
case 2: setScalePosition(*reinterpret_cast< ScalePos*>(_v)); break;
case 3: setSpacing(*reinterpret_cast< int*>(_v)); break;
case 4: setBorderWidth(*reinterpret_cast< int*>(_v)); break;
case 5: setMaxValue(*reinterpret_cast< double*>(_v)); break;
case 6: setMinValue(*reinterpret_cast< double*>(_v)); break;
case 7: setPipeWidth(*reinterpret_cast< int*>(_v)); break;
case 8: setValue(*reinterpret_cast< double*>(_v)); break;
}
_id -= 9;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 9;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 9;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 9;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 9;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 9;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 9;
}
#endif // QT_NO_PROPERTIES
return _id;
}
void PosEdit::updateButtons()
{
bool upEnabled = isEnabled() && (pos() < maxValue());
bool downEnabled = isEnabled() && (pos() > minValue());
//printf("PosEdit::updateButtons smpte:%d upEnabled:%d downEnabled:%d\n", smpte(), upEnabled, downEnabled);
controls->setStepEnabled(upEnabled, downEnabled);
}
int QProg::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: valueChanged((*reinterpret_cast< double(*)>(_a[1]))); break;
case 1: setValue((*reinterpret_cast< double(*)>(_a[1]))); break;
case 2: setMaxValue((*reinterpret_cast< double(*)>(_a[1]))); break;
case 3: setMinValue((*reinterpret_cast< double(*)>(_a[1]))); break;
case 4: setFontDim((*reinterpret_cast< int(*)>(_a[1]))); break;
case 5: setPrecision((*reinterpret_cast< int(*)>(_a[1]))); break;
case 6: setBarColor((*reinterpret_cast< QColor(*)>(_a[1]))); break;
default: ;
}
_id -= 7;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< double*>(_v) = value(); break;
case 1: *reinterpret_cast< double*>(_v) = minValue(); break;
case 2: *reinterpret_cast< double*>(_v) = maxValue(); break;
case 3: *reinterpret_cast< int*>(_v) = font(); break;
case 4: *reinterpret_cast< int*>(_v) = numPrec(); break;
case 5: *reinterpret_cast< QColor*>(_v) = color(); break;
}
_id -= 6;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setValue(*reinterpret_cast< double*>(_v)); break;
case 1: setMinValue(*reinterpret_cast< double*>(_v)); break;
case 2: setMaxValue(*reinterpret_cast< double*>(_v)); break;
case 3: setFontDim(*reinterpret_cast< int*>(_v)); break;
case 4: setPrecision(*reinterpret_cast< int*>(_v)); break;
case 5: setBarColor(*reinterpret_cast< QColor*>(_v)); break;
}
_id -= 6;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 6;
}
#endif // QT_NO_PROPERTIES
return _id;
}
bool AI::makeMove(SDL_Event *event){
// Init enemyTeam that this class can use
getEnemyTeam();
for(int index=0;index<team.size();index++){
currentIndex = index;
team[index].directionValues[0] = maxValue(Board->virtualBoard, team, enemyTeam, MAX_DEPTH, LEFT);
team[index].directionValues[1] = maxValue(Board->virtualBoard, team, enemyTeam, MAX_DEPTH, RIGHT);
if (team[index].isKing()) {
team[index].directionValues[3] = maxValue(Board->virtualBoard, team, enemyTeam, MAX_DEPTH, BACK_RIGHT);
team[index].directionValues[2] = maxValue(Board->virtualBoard, team, enemyTeam, MAX_DEPTH, BACK_LEFT);
}
cout<<"Index: "<<index<<" ("<< team[index].x << "," << team[index].y;
cout<<") Left: "<<team[index].directionValues[0]<<" Right: "<<team[index].directionValues[1];
cout<<" bLeft: "<<team[index].directionValues[2]<<" bRight: "<<team[index].directionValues[3]<<endl;
team[index].findBestDirection();
team[index].findLargestPotenial();
}
int bestPieceIndex = bestPiece(team);
cout<< "The chosen one: " << bestPieceIndex << " -> ("<< team[bestPieceIndex].x << "," << team[bestPieceIndex].y;
int x = team[bestPieceIndex].x;
int y = team[bestPieceIndex].y;
// Makes sure the move isnt out of bounds //
if (team[bestPieceIndex].potential != OUT_OF_BOUND) {
changeWithDirection(x, y, team[bestPieceIndex].bestDirection, false);
if(sameTeam(Board->virtualBoard[x][y],ENEMY_TEAM_NUMBER)){
// Changes it again for moving 2 units diagonally //
changeWithDirection(x, y, team[bestPieceIndex].bestDirection, false);
}
cout<<") best move: (" << x << "," << y <<")"<< endl;
movePiece(Board->virtualBoard, team, bestPieceIndex, x, y);
return true;
}
return false;
}
/*!
* \brief ET0_Penman_hourly http://www.cimis.water.ca.gov/cimis/infoEtoPmEquation.jsp
* \param heigth elevation above mean sea level (meters)
* \param normalizedTransmissivity normalized tramissivity [0-1] ()
* \param globalSWRadiation net Short Wave radiation (W m-2)
* \param airTemp air temperature (C)
* \param airHum relative humidity (%)
* \param windSpeed10 wind speed at 2 meters (m s-1)
* \return result
*/
double ET0_Penman_hourly(double heigth, double normalizedTransmissivity, double globalSWRadiation,
double airTemp, double airHum, double windSpeed10)
{
double mySigma; /*!< Steffan-Boltzman constant J m-2 h-1 K-4 */
double es; /*!< saturation vapor pressure (kPa) at the mean hourly air temperature in C */
double ea; /*!< actual vapor pressure (kPa) at the mean hourly air temperature in C */
double emissivity; /*!< net emissivity of the surface */
double netRadiation; /*!< net radiation (J m-2 h-1) */
double netLWRadiation; /*!< net longwave radiation (J m-2 h-1) */
double g; /*!< soil heat flux density (J m-2 h-1) */
double Cd; /*!< bulk surface resistance and aerodynamic resistance coefficient */
double tAirK; /*!< air temperature (Kelvin) */
double windSpeed2; /*!< wind speed at 2 meters (m s-1) */
double delta; /*!< slope of saturation vapor pressure curve (kPa C-1) at mean air temperature */
double pressure; /*!< barometric pressure (kPa) */
double lambda; /*!< latent heat of vaporization in (J kg-1) */
double gamma; /*!< psychrometric constant (kPa C-1) */
double firstTerm, secondTerm, denominator;
es = computeSatVapPressure(airTemp);
ea = airHum * es / 100.0;
emissivity = emissivityFromVaporPressure(ea);
tAirK = airTemp + ZEROCELSIUS;
mySigma = STEFAN_BOLTZMANN * HOUR_SECONDS;
netLWRadiation = minValue(normalizedTransmissivity, 1) * emissivity * mySigma * (pow(tAirK, 4));
/*! from [W m-2] to [J h-1 m-2] */
netRadiation = ALBEDO_CROP_REFERENCE * (3600 * globalSWRadiation) - netLWRadiation;
/*! values for grass */
if (netRadiation > 0)
{ g = 0.1 * netRadiation;
Cd = 0.24;
}
else
{
g = 0.5 * netRadiation;
Cd = 0.96;
}
delta = SaturationSlope(airTemp, es) / 1000; /*!< to kPa */
pressure = 101.3 * pow(((293 - 0.0065 * heigth) / 293), 5.26);
gamma = Psychro(pressure, airTemp);
lambda = LatentHeatVaporization(airTemp);
windSpeed2 = windSpeed10 * 0.748;
denominator = delta + gamma * (1 + Cd * windSpeed2);
firstTerm = delta * (netRadiation - g) / (lambda * denominator);
secondTerm = (gamma * (37 / tAirK) * windSpeed2 * (es - ea)) / denominator;
return maxValue(firstTerm + secondTerm, 0);
}
void heapSort(int keys[], int numKeys){
if(numKeys == 0) return;
heapHndl H = newHeap(numKeys);
for(int i = 0; i < numKeys; i++) insert(H, keys[i]);
for(int i = numKeys-1; i > -1; i--){
keys[i] = maxValue(H);
deleteMax(H);
}
freeHeap(&H);
}
int isBST2(struct node *node) {
if (node == NULL) return;
else {
int min = minValue(node);
int max = maxValue(node);
return (isBSTRecur(node,min,max));
}
}
void Foam::distributionModel::check() const
{
if (minValue() < 0)
{
FatalErrorInFunction
<< type() << "distribution: Minimum value must be greater than "
<< "zero." << nl << "Supplied minValue = " << minValue()
<< abort(FatalError);
}
if (maxValue() < minValue())
{
FatalErrorInFunction
<< type() << "distribution: Maximum value is smaller than the "
<< "minimum value:" << nl << " maxValue = " << maxValue()
<< ", minValue = " << minValue()
<< abort(FatalError);
}
}
/*!
\brief Recalculate the marker angle corresponding to the
current value
*/
void QwtKnob::recalcAngle()
{
// calculate the angle corresponding to the value
if ( maxValue() == minValue() )
{
d_data->angle = 0;
d_data->nTurns = 0;
}
else
{
d_data->angle = ( value() - 0.5 * ( minValue() + maxValue() ) )
/ ( maxValue() - minValue() ) * d_data->totalAngle;
d_data->nTurns = qFloor( ( d_data->angle + 180.0 ) / 360.0 );
d_data->angle = d_data->angle - d_data->nTurns * 360.0;
}
}
void Slider::rangeChange()
{
if (!hasUserScale())
d_scale.setScale(minValue(), maxValue(), d_maxMajor, d_maxMinor);
SliderBase::rangeChange();
repaint();
}
void LinearGauge::saveSettings( QSettings& pSettings )
{
// Range
pSettings.setValue("orientation", orientation());
pSettings.setValue("scalePosition", scalePosition());
pSettings.setValue("minValue", minValue());
pSettings.setValue("maxValue", maxValue());
// Ticks
pSettings.setValue("scaleMaxMajor", scaleMaxMajor());
pSettings.setValue("scaleMaxMinor", scaleMaxMinor());
pSettings.setValue("labels", scaleDraw()->hasComponent( QwtAbstractScaleDraw::Labels ));
pSettings.setValue("font", font().family());
pSettings.setValue("fontSize", font().pointSize());
// Pipe
pSettings.setValue("value", value());
pSettings.setValue("pipeWidth", pipeWidth());
pSettings.setValue("pipeColor", fillBrush().color().rgb());
// Alarm
pSettings.setValue("alarmEnabled", alarmEnabled());
pSettings.setValue("alarmLevel", alarmLevel());
pSettings.setValue("alarmBrush", alarmBrush().color().rgb());
// Color
pSettings.setValue("textColor", textColor().rgb());
pSettings.setValue("backgroundColor", backgroundColor().rgb());
AbstractGauge::saveSettings( pSettings );
}
/*!
Update the scale with the current attributes
\sa QwtDial::setScale
*/
void QwtDial::updateScale()
{
if ( d_scaleDraw )
{
d_scaleDraw->setScale(minValue(), maxValue(),
d_maxMajIntv, d_maxMinIntv, d_scaleStep);
}
}
