//! 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;
}
int distanceOfUint32(const vector<uint32_t> &w1, const vector<uint32_t> &w2)
{
int len1 = w1.size();
int len2 = w2.size();
int memo[100][100];
memset(memo, 0x00, 100 * 100 * sizeof(int));
for(int i = 1; i <= len1; ++i)
{
memo[i][0] = i;
}
for(int j = 1; j <= len2; ++j)
{
memo[0][j] = j;
}
for(int i = 1; i <= len1; ++i)
{
for(int j = 1; j <= len2; ++j)
{
if(w1[i-1] == w2[j-1])
{
memo[i][j] = memo[i-1][j-1];
}else
{
memo[i][j] = minValue(memo[i-1][j-1], memo[i][j-1], memo[i-1][j]) + 1;
}
}
}
// std::cout << memo[len1][len2]<<"____" << std::endl;
return memo[len1][len2];
}
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 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(){
int size = 6;
int arr[size];
int arr1[6]={1,2,3,4,5,6};
int arr2[6]={-11,-12,-13,-14,-15,-16};
int res[6];
int i;
fillRand3(arr, size);
for (i = 0; i < size; i++)
printf("%d\t", arr[i]);
printf("\nrez = %d\n",checkRand3(arr, size));
printf("sred = %.3f\n",meanValue(arr, size));
printf("min = %d\n", minValue(arr, size));
printf("index= %i\n", meanIndex(arr, size));
printf("index = %d\n", minIndex(arr, size));
printf("elem = %d\n", maxOccurance(arr, size));
printf("res = %d\n", diff(arr1, arr2, res, size));
sub(arr1, arr2, res, size);
for (i=0;i<size;i++)
printf("%d\t", res[i]);
printf("\neq= %d\n", eq(arr1, arr2, size));
land(arr1, arr2, res, size);
for (i=0;i<size;i++)
printf("%d\t", res[i]);
return 0;
}
void QRangeControl::subtractLine()
{
if ( value() - lineStep() < value() )
setValue( value() - lineStep() );
else
setValue( minValue() );
}
int distanceOfString(const std::string &strA, const std::string &strB)
{
int lenA = (int)strA.length()+1;
int lenB = (int)strB.length()+1;
int **c = new int*[lenA];
for(int i = 0; i < lenA; i++)
c[i] = new int[lenB];
for(int i = 0; i < lenA; i++) c[i][0] = i;
for(int j = 0; j < lenB; j++) c[0][j] = j;
for(int i = 1; i < lenA; i++)
{
for(int j = 1; j < lenB; j++)
{
if(strB[j-1] == strA[i-1])
c[i][j] = c[i-1][j-1];
else
c[i][j] = minValue(c[i][j-1], c[i-1][j], c[i-1][j-1]) + 1;
}
}
int ret = c[lenA-1][lenB-1];
for(int i = 0; i < lenA; i++)
delete [] c[i];
delete []c;
return ret;
}
//==============================================================================
value_type MoveSelector::maxValue(
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_negInfinity;
for (auto it = moves.begin(); it != moves.end(); ++it)
{
BitBoardPtr spResult = result(spBoard, *it);
v = std::max(v, minValue(spResult, depth-1, alpha, beta));
if (score >= beta)
{
return v;
}
alpha = std::max(alpha, v);
}
return v;
}
//==============================================================================
Move MoveSelector::GetBestMove(const value_type &maxDepth) const
{
BitBoardPtr spBoard = m_wpBoard.lock();
ValidMoveSet vms(m_wpMoveSet, spBoard);
MoveList moves = vms.GetMyValidMoves();
value_type bestValue = s_negInfinity;
Move bestMove;
for (auto it = moves.begin(); it != moves.end(); ++it)
{
BitBoardPtr spResult = result(spBoard, *it);
value_type oldVal = bestValue;
value_type min = minValue(spResult, maxDepth, s_negInfinity, s_posInfinity);
bestValue = std::max(bestValue, min);
if (bestValue > oldVal)
{
bestMove = *it;
}
}
return bestMove;
}
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 QDial::keyPressEvent( QKeyEvent * e )
{
switch ( e->key() ) {
case Key_Left: case Key_Down:
subtractLine();
break;
case Key_Right: case Key_Up:
addLine();
break;
case Key_Prior:
subtractPage();
break;
case Key_Next:
addPage();
break;
case Key_Home:
setValue( minValue() );
break;
case Key_End:
setValue( maxValue() );
break;
default:
e->ignore();
break;
}
}
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();
}
/*!
\brief Notify a change of the range
Called by QwtAbstractSlider
*/
void QwtKnob::rangeChange()
{
if ( autoScale() )
rescale( minValue(), maxValue() );
layoutKnob( true );
recalcAngle();
}
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);
}
float computeTminHourlyWeight(int myHour)
{
if (myHour >= 6 && myHour <= 14)
return (1 - ((float)myHour - 6) / 8);
else if (myHour > 14)
return (1 - minValue((24 - (float)myHour) + 6, 12) / 12);
else
return (1 - (6 - (float)myHour) / 12);
}
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;
}
int nrAtoms(soil::Crit3DLayer* layers, int nrLayers, double rootDepthMin, double* minThickness, int* atoms)
{
int multiplicationFactor = 1;
if (rootDepthMin > 0)
*minThickness = rootDepthMin;
else
*minThickness = layers[1].thickness;
for(int i=1; i<nrLayers; i++)
*minThickness = minValue(*minThickness, layers[i].thickness);
double tmp = *minThickness * 1.001;
if (tmp < 1)
multiplicationFactor = (int)(pow(10.0,-orderOfMagnitude(tmp)));
if (*minThickness < 1)
{
*minThickness = 1./multiplicationFactor;
}
int value;
int counter = 0;
for(int i=0; i<nrLayers; i++)
{
value = int(round(multiplicationFactor * layers[i].thickness));
atoms[i] = value;
counter += value;
}
return counter;
}
/* Given a non-empty binary search tree(ordered)
returns the minimum data value found on tree */
int minValue(struct node* root)
{
if(root->left == 0)
return root->data;
else
return minValue(root->left);
}
int AgentAB::maxValue(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_MIN;
vector<vector<int> >moveList = searchState_.successor(MAX);
if (depth == depthLimit && moveList.size() != 0) { // if there is a legal movement, at least use it
ansMove[0] = moveList[0][0];
ansMove[1] = moveList[0][1];
}
vector<vector<int> >::iterator iter;
vector<int> tmpPos;
for (iter = moveList.begin(); iter != moveList.end(); iter++) {
tmpPos = searchState_.maxPos;
searchState_.update(MAX, *iter);
int tmp = minValue( depth - 1, alpha, beta);
searchState_.moveBack(MAX, tmpPos);
if (v < tmp) {
v = tmp;
if (depth == depthLimit)
ansMove = (*iter);
}
if (v >= beta)
return v;
alpha = max(v, alpha);
}
return v;
}
void QRangeControl::subtractPage()
{
if ( value() - pageStep() < value() )
setValue( value() - pageStep() );
else
setValue( minValue() );
}
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 );
}
/*!
\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;
}
}
/*!
Sets the minimum value of the range to \a maxVal.
If necessary, the minValue() is adjusted so that the range remains
valid.
\sa maxValue() setMinValue()
*/
void QRangeControl::setMaxValue( int maxVal )
{
int minVal = minValue();
if ( minVal > maxVal )
minVal = maxVal;
setRange( minVal, maxVal );
}
struct Node* delete_key(struct Node *root, int key){
if(root == NULL){
return root;
}
if(key < root->data){
root->left = delete_key(root->left,key);
}else if(root->data < key){
root->right = delete_key(root->right,key);
}else{
//delete node with 0 or 1 child
if(root->left == NULL){
struct Node *temp = root->right;
free(root);
printf("\nproblem : %d",temp->data);
return temp;
}else if(root->right == NULL){
struct Node *temp = root->left;
free(root);
return temp;
}
//delete node with 2 child
struct Node *temp = minValue(root->right);
root->data = temp->data;
root->right = delete_key(root->right,temp->data);
}
return root;
}
/*!
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);
}
}
int minValue(struct node *p)
{
if (p->left == 0)
return;
else {
minValue(p->left);
return (p->data < p->left->data)? p->data:p->left->data;
}
}
void LpaStar::calcKey(LpaStarCell *cell) {
double key1, key2;
key2 = minValue(cell->g, cell->rhs);
key1 = key2 + cell->h;
cell->key[0] = key1;
cell->key[1] = key2;
}
