sf::FloatRect Rect::getAABB() const
{
sf::FloatRect aabb;
aabb.left = minVal(tl.getX(), tr.getX(), bl.getX(), br.getX());
aabb.top = minVal(tl.getY(), tr.getY(), bl.getY(), br.getY());
aabb.width = maxVal(tl.getX(), tr.getX(), bl.getX(), br.getX()) - aabb.left;
aabb.height = maxVal(tl.getY(), tr.getY(), bl.getY(), br.getY()) - aabb.top;
return aabb;
}
// make a report on the data collected so far and print it to a stream
void report(FILE *file) const
{
fprintf(file, "Statistics on: %s Num samples = %u SUM=%f\n", _name, samples(), sum());
if (_samples > 0)
fprintf(file, "MAX=%f MIN=%f Mean=%f StdDev=%f\n",
maxVal(), minVal(), mean(), stddev());
}
int MakingChange(int di[], int n, int change){
int i,j,temp1, temp2;
if(change== 0)
return 0;
for(i=1;i<=n;i++){
for(j=0;j<=change;j++){
if(j==0){
changeResult[i][j] = 0;
}
else{
temp1 = getChangeValue(i-1,j);
temp2 = getChangeValue(i, j-di[i]);
changeResult[i][j] = minVal(temp1,temp2+1 );
}
}
}
for(i=0;i<=n;i++){
for(j=0;j<=change;j++){
printf("%2d ",changeResult[i][j]);
}
printf("\n");
}
}
// make a report on the data collected so far and print it to a string buffer
// The buffer must be allocated by the caller (256 bytes should be enough)
void report(char *str) const
{
int l = sprintf(str, "Statistics on: %s Num samples = %u SUM=%f\n", _name, samples(), sum());
if (_samples > 0)
sprintf(str+l, "MAX=%f MIN=%f Mean=%f StdDev=%f\n",
maxVal(), minVal(), mean(), stddev());
}
//O(h)
//if a node has a right sub tree, inorder successor will be left most child of the right sub tree
//If not, then this has to be a left node, the successor is the closest ancestor v such that this node is a decendent of the left child of v
int InOrderSuccessorOfBST(struct node* root, struct node* node)
{
if(root == NULL)
return -1;
struct node* cur = root;
struct node* succ = NULL;
while(cur != NULL)
{
if(node->right)
{
return minVal(node->right);
}
else
{
if(cur->data > node->data)
{
succ = cur;
cur = cur->left;
}
else if(cur->data < node->data)
{
cur = cur->right;
}
else
break;
}
}
if(succ)
return succ->data;
else
return -1;
}
int QwtCounter::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: buttonReleased((*reinterpret_cast< double(*)>(_a[1]))); break;
case 1: valueChanged((*reinterpret_cast< double(*)>(_a[1]))); break;
case 2: btnReleased(); break;
case 3: btnClicked(); break;
case 4: textChanged(); break;
}
_id -= 5;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< int*>(_v) = numButtons(); break;
case 1: *reinterpret_cast< double*>(_v) = step(); break;
case 2: *reinterpret_cast< double*>(_v) = minVal(); break;
case 3: *reinterpret_cast< double*>(_v) = maxVal(); break;
case 4: *reinterpret_cast< int*>(_v) = stepButton1(); break;
case 5: *reinterpret_cast< int*>(_v) = stepButton2(); break;
case 6: *reinterpret_cast< int*>(_v) = stepButton3(); break;
case 7: *reinterpret_cast< double*>(_v) = value(); break;
case 8: *reinterpret_cast< bool*>(_v) = editable(); break;
}
_id -= 9;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setNumButtons(*reinterpret_cast< int*>(_v)); break;
case 1: setStep(*reinterpret_cast< double*>(_v)); break;
case 2: setMinValue(*reinterpret_cast< double*>(_v)); break;
case 3: setMaxValue(*reinterpret_cast< double*>(_v)); break;
case 4: setStepButton1(*reinterpret_cast< int*>(_v)); break;
case 5: setStepButton2(*reinterpret_cast< int*>(_v)); break;
case 6: setStepButton3(*reinterpret_cast< int*>(_v)); break;
case 7: setValue(*reinterpret_cast< double*>(_v)); break;
case 8: setEditable(*reinterpret_cast< bool*>(_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;
}
/* and the PerformMove function */
void *FindBestMoveThread1(void *data)
{
int i,x,best[50],numbest;
struct State state;
double val;
double maxv = -1000000.0;
int player;
int depth=1;
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
fprintf(stderr,"FindBestMoveThread1\n");
player = *((int*)data);
/* Set up the current state */
state.player = player;
memcpy(state.board,board,64*sizeof(char));
/* Find the legal moves for the current state */
FindLegalMoves(&state);
i = rand()%state.numLegalMoves;
memset(bestmove,0,12*sizeof(char));
memcpy(bestmove,state.movelist[i],MoveLength(state.movelist[i]));
evals=0;
while(1)
{
maxv = -1000000.0;
numbest=1;
best[0]=0;
for(x=0;x<state.numLegalMoves;x++)
{
State newState;
memcpy(&newState, &state, sizeof(State));
PerformMove(newState.board, newState.movelist[x],MoveLength(newState.movelist[x]));
newState.player = (newState.player==1) ? 2 : 1;
val = minVal(&newState, depth);
if(val>maxv)
{
best[0]=x;
numbest=1;
maxv = val;
}
if(val==maxv)
{
best[numbest++]=x;
}
}
memset(bestmove,0,12*sizeof(char));
i=best[rand()%numbest]; // pick a random best move
memcpy(bestmove, state.movelist[i], MoveLength(state.movelist[i]));
maxDepth=depth++;
}
return NULL;
}
int constructSTUtil(int hist[], int ss, int se, int* st, int si) {
if (ss == se)
return st[si] = ss;
int mid = midVal(ss, se);
st[si] = minVal(hist, constructSTUtil(hist, ss, mid, st, si*2 + 1),
constructSTUtil(hist, mid+1, se, st, si*2 + 2));
return st[si];
}
long constructSTUtil(long *arr,long ss,long se,long *st,long si){
if(ss==se){
st[si]=arr[ss];
return arr[ss];
}
long mid=getMid(ss,se);
long a=constructSTUtil(arr,ss,mid,st,si*2+1),
b=constructSTUtil(arr,mid+1,se,st,si*2+2);
st[si]=minVal(a,b);
return st[si];
}
int RMQUtil(int* hist, int* st, int ss, int se, int qs, int qe, int idx) {
if (qs <= ss && se <= qe)
return st[idx];
if (se < qs || ss > qe)
return -1;
int mid = midVal(ss, se);
return minVal(hist, RMQUtil(hist, st, ss, mid, qs, qe, 2*idx + 1),
RMQUtil(hist, st, mid+1, se, qs, qe, 2*idx + 2));
}
int constructSTUtil(int arr[], int ss, int se, int *st, int si)
{
if (ss == se) {
st[si] = arr[ss];
return arr[ss];
}
int mid = getMid(ss, se);
st[si] = minVal(constructSTUtil(arr, ss, mid, st, si*2+1),
constructSTUtil(arr, mid+1, se, st, si*2+2));
return st[si];
}
int RMQUtil(int *st, int ss, int se, int qs, int qe, int index)
{
if (qs <= ss && qe >= se)
return st[index];
if (se < qs || ss > qe)
return INT_MAX;
int mid = getMid(ss, se);
return minVal(RMQUtil(st, ss, mid, qs, qe, 2*index+1),
RMQUtil(st, mid+1, se, qs, qe, 2*index+2));
}
int main()
{
inputAndStore();
ll M,x,y,l,r,i;
ll sum=0;
scanf("%lld%lld%lld",&M,&x,&y);
buildST(1,0,N-1);
l=minVal(x,y);
r=maxVal(x,y);
sum=query(l,r,1,0,N-1);
//printf("%lld\n",sum);
for(i=2;i<=M;i++)
{
x=(x+7)%(N-1);
y=(y+11)%N;
l=minVal(x,y);
r=maxVal(x,y);
sum+=query(l,r,1,0,N-1);
}
printf("%lld\n",sum);
return 0;
}
void Node::initInternalPropagatedValuesVector(unsigned numNodes)
{
mInternalPropagatedValues.clear();
mInternalPropagatedValues.resize(numNodes);
for(unsigned i=0;i<numNodes;++i)
mInternalPropagatedValues[i] = 0.0;
//update self weight
mInternalPropagatedValues[getId()] = mSelfWeight;
//for successor edges
for(unsigned i=0;i<mSuccessorNodes.size();++i)
{
unsigned num_instances = mSuccessorNodes[i]->getNumDynamicInstances();
if(mSuccessorNodes[i]->getSCC() == getSCC())
mInternalPropagatedValues[mSuccessorNodes[i]->getId()] = minVal(num_instances,
mSuccessorNodes[i]->getSelfWeight());
else
mInternalPropagatedValues[mSuccessorNodes[i]->getId()] = minVal(num_instances, getSelfWeight() *
getSuccessorEdge(i)->getEdgeWeight() * mSuccessorNodes[i]->getSelfWeight());
}
}
long RMQUtil(long *st,long ss,long se,long qs,long qe,long index){
if(qs<=ss && qe>=se){
return st[index];
}
if(se<qs || ss>qe){
return LONG_MAX;
}
long mid=getMid(ss,se);
long a=
RMQUtil(st,ss,mid,qs,qe,2*index+1),
b=RMQUtil(st,mid+1,se,qs,qe,2*index+2);
return minVal(a,b);
}
bool Rect::pointInRect(const vec::Vector2& point, vec::Vector2& normal) const
{
//float rSum = tl.dist(tr) * tl.dist(bl);
float rSum = areaOf(tl, tr, bl) + areaOf(tr, br, bl);
float a1 = areaOf(tl, point, bl);
float a2 = areaOf(bl, point, br);
float a3 = areaOf(br, point, tr);
float a4 = areaOf(point, tr, tl);
float pSum = a1 + a2 + a3 + a4;
if (pSum - rSum > 2)
return false;
// Figure out which line is being intersected with
vec::Vector2 p1, p2;
float minArea = minVal(a1, a2, a3, a4);
if (minArea == a1)
{
p1 = tl;
p2 = bl;
}
else if (minArea == a2)
{
p1 = bl;
p2 = br;
}
else if (minArea == a3)
{
p1 = br;
p2 = tr;
}
else if (minArea == a4)
{
p1 = tr;
p2 = tl;
}
// Calculate the normal of this line
normal = (p1 - p2).rotate(PI / 2).setMag(1);
normal *= -1;
// Make sure the normal is pointing outwards
vec::Vector2 difC = point - this->getPos();
if (normal.angleBetween(difC) > 90)
normal *= -1;
return true;
}
void Maillage::geometry(const glm::vec3 ¢er, const char* obj, glm::vec3 &min, glm::vec3 &max) {
glm::vec3 minVal(1E100, 1E100, 1E100), maxVal(-1E100, -1E100, -1E100);
FILE* f;
fopen_s(&f, obj, "rt");
//= fopen(obj, "r");
while (!feof(f)) {
char line[255];
fgets(line, 255, f);
if (line[0]=='v' && line[1]==' ') {
glm::vec3 vec;
sscanf_s(line, "v %f %f %f\n", &vec[0], &vec[2], &vec[1]);
vec[2] = -vec[2];
glm::vec3 p = vec + center;
//std::cout << p.x << " " << p.y << " " << p.z << std::endl;
geom.push_back(p);
maxVal[0] = std::max(maxVal[0], p[0]);
maxVal[1] = std::max(maxVal[1], p[1]);
maxVal[2] = std::max(maxVal[2], p[2]);
minVal[0] = std::min(minVal[0], p[0]);
minVal[1] = std::min(minVal[1], p[1]);
minVal[2] = std::min(minVal[2], p[2]);
min = glm::vec3(minVal[0], minVal[1], minVal[2]);
max = glm::vec3(maxVal[0], maxVal[1], maxVal[2]);
}
if (line[0]=='v' && line[1]=='n') {
glm::vec3 vec;
sscanf_s(line, "vn %f %f %f\n", &vec[0], &vec[2], &vec[1]);
vec[2] = -vec[2];
normales.push_back(vec);
}
if (line[0]=='f') {
int i0, i1, i2;
int j0,j1,j2;
int k0,k1,k2;
sscanf_s(line, "f %u//%u %u//%u %u//%u\n", &i0, &k0, &i1, &k1, &i2, &k2 );
topo.push_back(i0-1);
topo.push_back(i1-1);
topo.push_back(i2-1);
normalIds.push_back(k0-1);
normalIds.push_back(k1-1);
normalIds.push_back(k2-1);
}
}
/*boundingSphere.C = 0.5*(minVal+maxVal);
boundingSphere.R = sqrt((maxVal-minVal).sqrNorm())*0.5;*/
fclose(f);
}
/* A recursive function to get the minimum value in a given range of array
indexes. The following are parameters for this function.
st --> Pointer to segment tree
index --> Index of current node in the segment tree. Initially 0 is
passed as root is always at index 0
ss & se --> Starting and ending indexes of the segment represented by
current node, i.e., st[index]
qs & qe --> Starting and ending indexes of query range */
int RMQUtil(int *st, int ss, int se, int qs, int qe, int index)
{
// If segment of this node is a part of given range, then return the
// min of the segment
if (qs <= ss && qe >= se)
return st[index];
// If segment of this node is outside the given range
if (se < qs || ss > qe)
return INT_MAX;
// If a part of this segment overlaps with the given range
int mid = getMid(ss, se);
return minVal(RMQUtil(st, ss, mid, qs, qe, 2*index+1),
RMQUtil(st, mid+1, se, qs, qe, 2*index+2));
}
// A recursive function that constructs Segment Tree for array[ss..se].
// si is index of current node in segment tree st
int constructSTUtil(int arr[], int ss, int se, int *st, int si)
{
// If there is one element in array, store it in current node of
// segment tree and return
if (ss == se)
{
st[si] = arr[ss];
return arr[ss];
}
// If there are more than one elements, then recur for left and
// right subtrees and store the minimum of two values in this node
int mid = getMid(ss, se);
st[si] = minVal(constructSTUtil(arr, ss, mid, st, si*2+1),
constructSTUtil(arr, mid+1, se, st, si*2+2));
return st[si];
}
/*
* Returns the maximum value from a tree.
*/
double maxVal(double alpha, double beta, struct State *state, int depth)
{
int x;
struct State newState;
/* If we've reached the depth limit then evaluate this node and return its
* value. */
if (depth <= 0)
{
return evaluateBoard(state);
}
--depth; /* descend one level in the tree */
FindLegalMoves(state);
/* Walk the move list and find the best one. */
for (x=0; x<state->numLegalMoves; ++x)
{
/* Check to see if this thread has been cancelled before moving on. */
pthread_testcancel();
/* Copy the current board state. */
memcpy(&newState, state, sizeof(struct State));
/* Perform a move on the copied state. */
PerformMove(newState.board,
newState.movelist[x],
MoveLength(newState.movelist[x]));
/* Toggle the current player. */
newState.player = (newState.player == 1) ? 2 : 1;
/* Perform a depth limited MiniMax search for the best move.
* Uses Alpha-Beta pruning. */
alpha = MAX(alpha, minVal(alpha, beta, &newState, depth));
if (alpha >= beta)
{
return beta;
}
}
return alpha;
}
//O(h) where h is the height of the BST
int InOrderSuccessorOfBSTusingParentPtr(struct node* node)
{
if(node == NULL)
return;
if(node->right)
return minVal(node->right);
else
{
struct node* p = node->parent;
while(p!= NULL && node== p->right)
{
node = p;
p = node->parent;
}
return p->data;
}
return -1;
}
double maxVal(State *state, int depth)
{
int x;
double maxv=-1000000.0;
if(depth--<=0) return evalBoard1(state);
FindLegalMoves(state);
for(x=0;x<state->numLegalMoves;x++)
{
State newState;
memcpy(&newState, state, sizeof(State));
PerformMove(newState.board, newState.movelist[x],MoveLength(newState.movelist[x]));
newState.player = (newState.player==1) ? 2 : 1;
maxv = MAX(minVal(&newState, depth),maxv);
}
return maxv;
}
void Experiment2D22::scaling() {
//scaling the [min,max] to the range [a,b]
//f(x) = (b-a)(x-min)
// ------------ + a
// max - min
int rows = pData.size();
int cols = pData[0].size();
vector<float> minVal(cols,INT_MAX);
vector<float> maxVal(cols,INT_MIN );
float a, b;
a = 0;
b = 5;
for (int i = 0;i < rows;i++) {
for (int j = 0;j < cols;j++) {
if (pData[i][j] > maxVal[j])
{
maxVal[j] = pData[i][j];
}
if (pData[i][j] < minVal[j])
{
minVal[j] = pData[i][j];
}
}
}
for (int i = 0;i < rows;i++) {
vector<float> temp;
for (int j = 0;j < cols;j++) {
float t;
t = ((b - a) * (pData[i][j] - minVal[j]) / (maxVal[j] - minVal[j])) + a;
temp.push_back(t);
}
scaledData.push_back(temp);
}
}
//----------------------------------------------------------------------
// test absolute value
//----------------------------------------------------------------------
TEST_F(lfpTest, Absolute) {
for (size_t idx=0; idx < addsub_cnt; ++idx) {
LFP op1(addsub_tab[idx][0].h, addsub_tab[idx][0].l);
LFP op2(op1.abs());
ASSERT_TRUE(op2.signum() >= 0);
if (op1.signum() >= 0)
op1 -= op2;
else
op1 += op2;
ASSERT_EQ(LFP(0,0), op1);
}
// There is one special case we have to check: the minimum
// value cannot be negated, or, to be more precise, the
// negation reproduces the original pattern.
LFP minVal(0x80000000, 0x00000000);
LFP minAbs(minVal.abs());
ASSERT_EQ(-1, minVal.signum());
ASSERT_EQ(minVal, minAbs);
}
int MyProcFileWrite(struct file *file, const char *buf, unsigned long count, void *data) {
unsigned long length=count;
struct PrivateData *localData = &myData;
spin_lock(&localData->numOpenLock);
(localData->numOpens)++;
spin_unlock(&localData->numOpenLock);
length = minVal((unsigned long) MAX_ALLOWABLE_LEN, count);
if(down_interruptible(&localData->sem))
return -ERESTARTSYS;
if(copy_from_user(localData->userGivenPID, buf, length))
return -EFAULT;
up(&localData->sem);
localData->userGivenPID[length-1]='\0';
if(length >=1)
localData->fFlag =1;
printk(KERN_INFO"UCSC-LDD: A4: Requested PID: %s\n",localData->userGivenPID);
spin_lock(&localData->numOpenLock);
(localData->numOpens)--;
spin_unlock(&localData->numOpenLock);
return length;
}
int Solution::nthUglyNumber(int n){
int *ugly = new int[n];
memset(ugly, 0, sizeof(int) * n);
ugly[0] = 1;
int factor2 = 2, factor3 = 3, factor5 = 5;
int index2, index3, index5;
index2 = index3 = index5 = 0;
for(int i=1; i<n; i++){
int minNum = minVal(factor2, factor3, factor5);
ugly[i] = minNum;
if(factor2 == minNum)
factor2 = 2 * ugly[++index2];
if(factor3 == minNum)
factor3 = 3 * ugly[++index3];
if(factor5 == minNum)
factor5 = 5 * ugly[++index5];
}
return ugly[n-1];
}
static inline bool isValid64Bit(int64_t v, wholenumber_t digits) {
digits = minVal(digits, ARGUMENT_DIGITS);
return v < (int64_t)validMaxWhole[digits - 1] && v > -(int64_t)validMaxWhole[digits - 1];
}
static inline bool isValid(wholenumber_t v, wholenumber_t digits) {
return abs(v) < validMaxWhole[minVal(digits, ARGUMENT_DIGITS) - 1];
}
MeshBoxes readObj(const glm::vec3 ¢er, const char* obj) {
QVector<glm::vec3> vertices;
QVector<glm::vec3> normals;
QVector<int> faces;
QVector<int> normalIds;
glm::vec3 minVal(1E100, 1E100, 1E100), maxVal(-1E100, -1E100, -1E100);
FILE* f = fopen(obj, "r");
while (!feof(f)) {
char line[255];
fgets(line, 255, f);
if (line[0]=='v' && line[1]==' ') {
glm::vec3 vec;
sscanf(line, "v %f %f %f\n", &(vec.x), &(vec.z), &(vec.y));
vec.z = -vec.z;
glm::vec3 p = vec*50.f + center;
vertices.push_back(p);
maxVal[0] = std::max(maxVal[0], p[0]);
maxVal[1] = std::max(maxVal[1], p[1]);
maxVal[2] = std::max(maxVal[2], p[2]);
minVal[0] = std::min(minVal[0], p[0]);
minVal[1] = std::min(minVal[1], p[1]);
minVal[2] = std::min(minVal[2], p[2]);
}
if (line[0]=='v' && line[1]=='n') {
glm::vec3 vec;
sscanf(line, "vn %f %f %f\n", &(vec.x), &(vec.z), &(vec.y));
vec.z = -vec.z;
normals.push_back(vec);
}
if (line[0]=='f') {
int i0, i1, i2;
int j0,j1,j2;
int k0,k1,k2;
sscanf(line, "f %u/%u/%u %u/%u/%u %u/%u/%u\n", &i0, &j0, &k0, &i1, &j1, &k1, &i2, &j2, &k2 );
faces.push_back(i0-1);
faces.push_back(i1-1);
faces.push_back(i2-1);
normalIds.push_back(k0-1);
normalIds.push_back(k1-1);
normalIds.push_back(k2-1);
}
}
fclose(f);
std::cout << "Min : " << minVal.x << " " << minVal.y << " " << minVal.z << std::endl;
std::cout << "Max : " << maxVal.x << " " << maxVal.y << " " << maxVal.z << std::endl;
QVector<int> indicesTriangles(faces.size()/3);
for (int i = 0; i < faces.size()/3; i++)
{
indicesTriangles[i] = i*3;
}
Box boundingBox{minVal, maxVal, indicesTriangles};
Mesh mesh{vertices, normals, faces, normalIds};
MeshBoxes meshBox{mesh, boundingBox};
divideMeshBox(meshBox);
return meshBox;
}
void Node::updateSelfWeight(double X)
{
mSelfWeight += X;
mSelfWeight = minVal(mSelfWeight, getNumDynamicInstances());
}
