char *video_save (int row1, int col1, int row2, int col2)
{
char *s;
int r, ws, lw, lls;
col1 = max1 (0, min1 (col1, COLS-1));
col2 = max1 (0, min1 (col2, COLS-1));
row1 = max1 (0, min1 (row1, ROWS-1));
row2 = max1 (0, min1 (row2, ROWS-1));
ws = (row2-row1+1)*(col2-col1+1);
lw = col2-col1+1;
lls = sizeof(int) * 4;
s = malloc (ws*2 + lls);
((int *)s)[0] = row1;
((int *)s)[1] = col1;
((int *)s)[2] = row2;
((int *)s)[3] = col2;
for (r=row1; r<=row2; r++)
{
memcpy (s+(r-row1)*lw+lls, scrn_cache_chars+r*COLS+col1, lw);
memcpy (s+(r-row1)*lw+ws+lls, scrn_cache_attrs+r*COLS+col1, lw);
}
return s;
}
void video_restore (char *s)
{
int r, ws, lw, lls;
int row1, col1, row2, col2;
if (s == NULL) return;
row1 = ((int *)s)[0];
col1 = ((int *)s)[1];
row2 = ((int *)s)[2];
col2 = ((int *)s)[3];
ws = (row2-row1+1)*(col2-col1+1);
lw = col2 - col1 + 1;
lls = sizeof(int) * 4;
if (row1 > row2 || row1 >= ROWS ||
col1 > col2 || col1 >= COLS)
{
free (s);
return;
}
for (r=row1; r<=min1(row2, ROWS-1); r++)
{
memcpy (scrn_cache_chars+r*COLS+col1, s+(r-row1)*lw+lls, min1(col2-col1+1, COLS-1-col1+1));
memcpy (scrn_cache_attrs+r*COLS+col1, s+(r-row1)*lw+ws+lls, min1(col2-col1+1, COLS-1-col1+1));
}
free (s);
}
int Dijkstra1(int s,int e)
{
int i,j;
for(i=1;i<=C;i++)
{
hash[i]=true;
path1[i]=-1;
}
path1[s]=INF;
for(i=1;i<=C;i++)
{
int min=-1,w=-1;
for(j=1;j<=C;j++)
{
if(hash[j]&&path1[j]>min)
{min=path1[j];w=j;}
}
if(w==-1)
break;
hash[w]=false;
for(j=1;j<=C;j++)
{
if(map1[w][j]!=-1&&path1[j]<min1(path1[w],map1[w][j]))
path1[j]=min1(path1[w],map1[w][j]);
}
}
return path1[e];
}
void select(HuffmanTree huffmanTree, int i, int *select1, int *select2) {
int j;
*select1 = min1(huffmanTree, i);
*select2 = min1(huffmanTree, i);
if (*select1 > *select2) {
j = *select1;
*select1 = *select2;
*select2 = j;
}
}
void select(HuffmanTree t,int i,int *s1,int *s2)
{ /* s1为最小的两个值中序号小的那个 */
int j;
*s1=min1(t,i);
*s2=min1(t,i);
if(*s1>*s2)
{
j=*s1;
*s1=*s2;
*s2=j;
}
}
void addlims_(float* STARPAR, short int* JRECT)
{
/* both passed vars are 1d arrays and do not need to be dereferenced
as a seperate step */
/* renaming tuneable variables */
float NPHSUB = (float)tune6_.nphsub;
float IHTAB = (float)tune22_.ihtab;
/* substance of subroutine begins here */
float TEMP, FUDGEX, FUDGEY;
float BETA6;
if (strncmp(tune16_.flags[0], "EXTPGAUSS", 5) == 0){
BETA6 = STARPAR[8];
}
else{
BETA6 = tune17_.beta6;
}
if (STARPAR[1] > 0.0f){
TEMP = powf( ((STARPAR[1]/NPHSUB)*(6.0f/BETA6)), 0.33333333f );
if (STARPAR[4] > 0.0f){
FUDGEX = sqrtf(TEMP*STARPAR[4]*2.0f);
}
else{
FUDGEX = 10.0f;
}
if (STARPAR[6] > 0.0f){
FUDGEY = sqrtf(TEMP*STARPAR[6]*2.0f);
}
else{
FUDGEY = 10.0f;
}
}
else{
FUDGEX = 10.0f;
FUDGEY = 10.0f;
}
FUDGEX = 2.0f * min1(FUDGEX, IHTAB-2.0f);
FUDGEY = 2.0f * min1(FUDGEY, IHTAB-2.0f);
JRECT[0] = STARPAR[2] - FUDGEX;
JRECT[1] = STARPAR[2] + FUDGEX;
JRECT[2] = STARPAR[3] - FUDGEY;
JRECT[3] = STARPAR[3] + FUDGEY;
}
void Clock::displayColor(bool onOff)
{
Digit hour1(x, y), hour2(x, y+10), min1(x, y+25), min2(x, y+35), sec1(x, y+50), sec2(x, y+60);
hour1.changeColor(true);
hour2.changeColor(true);
min1.changeColor(true);
min2.changeColor(true);
sec1.changeColor(true);
sec2.changeColor(true);
if(onOff)
{
clearDisplay();
hour1.display(hr/10, true);
hour2.display(hr%10, true);
min1.display(min/10, true);
min2.display(min%10, true);
sec1.display(sec/10, isSec);
sec2.display(sec%10, isSec);
if(isPM)
{
attron(COLOR_PAIR(BLACKONYELLOW));
mvprintw(x+6, y-5, "PM");
attroff(COLOR_PAIR(BLACKONYELLOW));
}
else
{
attron(COLOR_PAIR(WHITEONBLACK));
mvprintw(x+6, y-5, " ");
}
refresh();
}
else
clearDisplay();
}
int main()
{
char a=min1('z','b');
std::cout<<a<<"\n";
int b=min2(1,8);
std::cout<<b;
}
void video_put_n_char (char c, int n, int row, int col)
{
if (n <= 0 || row < 0 || col < 0) return;
if (row >= ROWS || col >= COLS) return;
n = min1 (n, COLS-col);
memset (scrn_cache_chars+row*COLS+col, c == '\0' ? ' ' : c, n);
}
void video_put_n_attr (char a, int n, int row, int col)
{
if (n <= 0 || row < 0 || col < 0) return;
if (row >= ROWS || col >= COLS) return;
n = min1 (n, COLS-col);
memset (scrn_cache_attrs+row*COLS+col, a, n);
}
// minimize a single link (see "PatchMatch" - page 4)
void minimizeLinkNNF(NNF_P nnf, int x, int y, int dir)
{
int xp,yp,dp,wi, xpi, ypi;
//Propagation Up/Down
if (x-dir>0 && x-dir<nnf->input->image->height) {
xp = nnf->field[x-dir][y][0]+dir;
yp = nnf->field[x-dir][y][1];
dp = distanceNNF(nnf,x,y, xp,yp);
if (dp<nnf->field[x][y][2]) {
nnf->field[x][y][0] = xp;
nnf->field[x][y][1] = yp;
nnf->field[x][y][2] = dp;
}
}
//Propagation Left/Right
if (y-dir>0 && y-dir<nnf->input->image->width) {
xp = nnf->field[x][y-dir][0];
yp = nnf->field[x][y-dir][1]+dir;
dp = distanceNNF(nnf,x,y, xp,yp);
if (dp<nnf->field[x][y][2]) {
nnf->field[x][y][0] = xp;
nnf->field[x][y][1] = yp;
nnf->field[x][y][2] = dp;
}
}
//Random search
wi=nnf->output->image->width;
xpi=nnf->field[x][y][0];
ypi=nnf->field[x][y][1];
int r=0;
while (wi>0) {
r=(rand() % (2*wi)) -wi;
xp = xpi + r;
r=(rand() % (2*wi)) -wi;
yp = ypi + r;
xp = (int)(max1(0, min1(nnf->output->image->height-1, xp )));
yp = (int)(max1(0, min1(nnf->output->image->width-1, yp )));
dp = distanceNNF(nnf,x,y, xp,yp);
if (dp<nnf->field[x][y][2]) {
nnf->field[x][y][0] = xp;
nnf->field[x][y][1] = yp;
nnf->field[x][y][2] = dp;
}
wi/=2;
}
}
void video_put_str (char *s, int n, int row, int col)
{
if (n <= 0 || row < 0 || col < 0) return;
if (row >= ROWS || col >= COLS) return;
n = min1 (n, COLS-col);
memcpy (scrn_cache_chars+row*COLS+col, s, n);
fix_string (scrn_cache_chars+row*COLS+col, n);
}
int main()
{
// min1(foo{}, foo{}); // error - invalid operands to <
min1(10, 20);
// min2(foo{}, foo{}); // no matching function min2
min2(10, 20);
}
// initialize field from an existing (possibily smaller) NNF
void initializeNNFFromOtherNNF(NNF_P nnf, NNF_P otherNnf)
{
int fx, fy, x, y, xlow, ylow;
// field
allocNNFField(nnf);
fy = nnf->fieldW/otherNnf->fieldW;
fx = nnf->fieldH/otherNnf->fieldH;
for (x=0;x<nnf->fieldH;++x) {
for (y=0;y<nnf->fieldW;++y) {
xlow = (int)(min1(x/fx, otherNnf->input->image->height-1));
ylow = (int)(min1(y/fy, otherNnf->input->image->width-1));
nnf->field[x][y][0] = otherNnf->field[xlow][ylow][0]*fx;
nnf->field[x][y][1] = otherNnf->field[xlow][ylow][1]*fy;
nnf->field[x][y][2] = DSCALE;
}
}
initializeNNF(nnf);
}
void video_init (int rows, int cols)
{
int row;
char *scrn_cache_chars1, *scrn_cache_attrs1;
// free old store, create new one
if (scrn_store_chars != NULL) free (scrn_store_chars);
if (scrn_store_attrs != NULL) free (scrn_store_attrs);
scrn_store_chars = malloc (rows*cols);
scrn_store_attrs = malloc (rows*cols);
// allocate new backing store buffers
scrn_cache_chars1 = malloc (rows*cols);
scrn_cache_attrs1 = malloc (rows*cols);
memset (scrn_cache_chars1, ' ', rows*cols);
memset (scrn_cache_attrs1, fl_clr.background, rows*cols);
if (scrn_cache_chars != NULL && scrn_cache_attrs != NULL)
{
for (row=0; row < min1(ROWS,rows); row++)
{
memcpy (scrn_cache_chars1+row*cols, scrn_cache_chars+row*COLS, min1(cols, COLS));
memcpy (scrn_cache_attrs1+row*cols, scrn_cache_attrs+row*COLS, min1(cols, COLS));
}
free (scrn_cache_chars);
free (scrn_cache_attrs);
CURSOR_ROW = min1 (rows-1, CURSOR_ROW);
CURSOR_COL = min1 (cols-1, CURSOR_COL);
}
else
{
CURSOR_ROW = 0;
CURSOR_COL = 0;
}
scrn_cache_chars = scrn_cache_chars1;
scrn_cache_attrs = scrn_cache_attrs1;
// bring the screen to the initial state
ROWS = rows;
COLS = cols;
set_cursor (cursor_store);
video_update (1);
}
static double higgspotent_(void)
{ int i,j;
double ee,sw,cw,lmax;
double MZ,alfEMZ,tb,At,Ab;
char name[10];
MZ=findValW("MZ");
alfEMZ=findValW("alfEMZ");
At=findValW("At");
Ab=findValW("Ab");
tb=findValW("tb");
for(i=1;i<=2;i++) for(j=1;j<=2;j++)
{ sprintf(name,"Pa%d%d",i,j); Pa_[i-1][j-1]=findValW(name);}
for(i=1;i<=3;i++) for(j=1;j<=3;j++)
{ sprintf(name,"Zh%d%d",i,j); Zh_[i-1][j-1]=findValW(name);}
for(i=1;i<=5;i++) for(j=1;j<=5;j++)
{ sprintf(name,"Zn%d%d",i,j); Zn_[i-1][j-1]=findValW(name);}
extpar.tb = findValW("tb");
extpar.Lambda = findValW("Lambda");
extpar.Kappa = findValW("Kappa");
extpar.aLambda = findValW("aLmbd0");
extpar.vev=findValW("vev");
ee=sqrt(4*M_PI*alfEMZ);
sw=sin(asin(extpar.vev*sqrt(2.0)*ee/MZ)/2);
cw=sqrt(1.0-sw*sw);
extpar.mw=MZ*cw;
extpar.g2=ee*ee/(sw*cw)/(sw*cw)/2;
extpar.aLambda=min1(extpar.aLambda-1, extpar.aLambda+1, varAlam);
varAlam(extpar.aLambda);
assignValW("mu",extpar.mu);
assignValW("aLmbda",extpar.aLambda);
assignValW("aKappa",extpar.aKappa);
fillNeutralinoMassMatrix();
for(i=1;i<=5;i++) {sprintf(name,"la%d",i); assignValW(name, La[i]);}
for(i=1;i<=2;i++) {sprintf(name,"la%ds",i); assignValW(name,Las[i]);}
assignValW("lass", Lass);
lmax=0;
for(i=0;i<10;i++)
{ if(lmax<fabs(La[i]))lmax=fabs(La[i]);
if(lmax<fabs(Las[i]))lmax=fabs(Las[i]);
}
if(lmax<fabs(Lass))lmax=fabs(Lass);
if(nCall>2000) return -1;
else return lmax;
}
void Clock::clearDisplay()
{
Digit hour1(x, y), hour2(x, y+10), min1(x, y+25), min2(x, y+35), sec1(x, y+50), sec2(x, y+60);
hour1.display(8, false);
hour2.display(8, false);
min1.display(8, false);
min2.display(8, false);
sec1.display(8, false);
sec2.display(8, false);
attron(COLOR_PAIR(WHITEONBLACK));
mvprintw(x+6, y-5, " "); //erase PM indicator
refresh();
}
glm::uvec2 Indigo::UIGroup::min_size() const
{
glm::uvec2 min(0);
for (OOBase::Vector<OOBase::SharedPtr<UIWidget>,OOBase::ThreadLocalAllocator>::const_iterator i=m_children.begin();i;++i)
{
if ((*i)->visible())
{
glm::uvec2 min1((*i)->min_size());
min1 += (*i)->position();
min = glm::max(min1,min);
}
}
return min;
}
///
//Checks for collision between two axis aligned bounding box by seeing
//if they overlap on each axis.
//
//Parameters:
// aabb1: The first axis aligned bounding box to test
// aabb2: The second axis aligned bounding box to test
//
//Returns:
// true if colliding, else false.
bool CheckCollision(const AABB &aabb1, const AABB &aabb2)
{
//Find the max and min points for each box
glm::vec3 min1(aabb1.center - (aabb1.dimensions*0.5f));
glm::vec3 max1(aabb1.center + (aabb1.dimensions*0.5f));
glm::vec3 min2(aabb2.center - (aabb2.dimensions*0.5f));
glm::vec3 max2(aabb2.center + (aabb2.dimensions*0.5f));
//If there is overlap on each axis, we have a collision
if (max1.x > min2.x && min1.x < max2.x)
if (max1.y > min2.y && min1.y < max2.y)
if (max1.z > min2.z && min1.z < max2.z)
return true;
return false;
}
int main(int argc, char* argv[])
{
Mat<float> hwd((float)4,3,1);
BoxShape box( NULL, hwd);
Mat<float> pointsB1[8];
for(int i=8;i--;) pointsB1[i] = Mat<float>(0.0f,3,1);
//register the position of the 8 points composing b1:
Mat<float> min1((float)0,3,1);
Mat<float> max1((float)0,3,1);
min1.set( -box.getHeight()/2.0f, 1,1);
min1.set( -box.getWidth()/2.0f, 2,1);
min1.set( -box.getDepth()/2.0f, 3,1);
max1.set( -min1.get(1,1), 1,1);
max1.set( -min1.get(2,1), 2,1);
max1.set( -min1.get(3,1), 3,1);
int col = 0;
for(int pm1=2;pm1--;)
{
for(int pm2=2;pm2--;)
{
for(int pm3=2;pm3--;)
{
pointsB1[col].set( pm1*( min1.get(1,1) ) + (1-pm1)*( max1.get(1,1) ), 1,1);
pointsB1[col].set( pm2*( min1.get(2,1) ) + (1-pm2)*( max1.get(2,1) ), 2,1);
pointsB1[col].set( pm3*( min1.get(3,1) ) + (1-pm3)*( max1.get(3,1) ), 3,1);
col++;
}
}
}
for(int i=8;i--;) pointsB1[i].afficher();
return 0;
}
Vec2 CollisionDetector::AABBToAABB(const Rect& rect1, const Rect& rect2) {
// Prevents false collision if either rects has no width and height
if ((rect1.GetW() == 0 && rect1.GetH() == 0) ||
(rect2.GetW() == 0 && rect2.GetH() == 0)) {
return Vec2(0.0, 0.0);
}
Vec2 min1(rect1.GetX(), rect1.GetY());
Vec2 max1(rect1.GetX() + rect1.GetW(), rect1.GetY() + rect1.GetH());
Vec2 min2(rect2.GetX(), rect2.GetY());
Vec2 max2(rect2.GetX() + rect2.GetW(), rect2.GetY() + rect2.GetH());
if ((max1.GetX() < min2.GetX()) || (max1.GetY() < min2.GetY())) {
return Vec2(0.0, 0.0);
}
if ((max2.GetX() < min1.GetX()) || (max2.GetY() < min1.GetY())) {
return Vec2(0.0, 0.0);
}
// Potential resolution offsets
double negX = max1.GetX() - min2.GetX();
double posX = max2.GetX() - min1.GetX();
double negY = max1.GetY() - min2.GetY();
double posY = max2.GetY() - min1.GetY();
// Returns the component vector that needs the least offset to resolve the collision
if (negX <= posX && negX <= negY && negX <= posY) {
return Vec2(-negX, 0.0);
}
else if (posX <= negY && posX <= posY) {
return Vec2(posX, 0.0);
}
else if (negY <= posY) {
return Vec2(0.0, -negY);
}
else {
return Vec2(0.0, posY);
}
return Vec2(0.0, 0.0);
}
int main()
{
int c,d,i,j;
scanf("%d%d",&c,&d);
int max=b[1][1];
for(i=1;i<=c;i++)
{
for(j=1;j<=d;j++)
{
b[0][1]=0;
scanf("%d",&a[i][j]);
if(a[i][j-1]==a[i-1][j-1]&&a[i-1][j-1]==a[i-1][j])
b[i][j]=min1(b[i][j-1],b[i-1][j-1],b[i-1][j])+1;
else
{
if(a[i][j-1]!=a[i-1][j-1]||a[i-1][j-1]!=a[i-1][j])
b[i][j]=1;
}
if(b[i][j]>max)
max=b[i][j];
}
}
printf("%d",max);
}
/* Returns a matrix made up with the coordinates of intersecting points in the World frame of b1 that are within b2. If there are none, it returns a zero 3x8 matrix.
*/
Mat<float> testOBBOBB( RigidBody& b1, RigidBody& b2, bool& intersect)
{
float precision = 1e-3f;
Mat<float> ret((float)0,3,1);
bool initialized = false;
BoxShape& box1 = (BoxShape&)(b1.getShapeReference());
BoxShape& box2 = (BoxShape&)(b2.getShapeReference());
Mat<float> pointsB1((float)0,3,8);
//register the position of the 8 points composing b1:
Mat<float> min1((float)0,3,1);
Mat<float> max1((float)0,3,1);
min1.set( -box1.getHeight()/2.0f, 1,1);
min1.set( -box1.getWidth()/2.0f, 2,1);
min1.set( -box1.getDepth()/2.0f, 3,1);
max1.set( -min1.get(1,1), 1,1);
max1.set( -min1.get(2,1), 2,1);
max1.set( -min1.get(3,1), 3,1);
int col = 1;
Mat<float> temp(3,1);
Mat<float> voronoiTemp(3,1);
for(int pm1=2;pm1--;)
{
for(int pm2=2;pm2--;)
{
for(int pm3=2;pm3--;)
{
Mat<float> tempL(3,1);
tempL.set( pm1*( min1.get(1,1) ) + (1-pm1)*( max1.get(1,1) ), 1,1);
tempL.set( pm2*( min1.get(2,1) ) + (1-pm2)*( max1.get(2,1) ), 2,1);
tempL.set( pm3*( min1.get(3,1) ) + (1-pm3)*( max1.get(3,1) ), 3,1);
//--------------------
//let us compute its coordinate in the world frame :
temp = b1.getPointInWorld( tempL);
#ifdef debug
b1.getPose().exp().afficher();
b2.getPose().exp().afficher();
tempL.afficher();
temp.afficher();
#endif
//----------------------
//let us find its associated projected point :
voronoiTemp = closestPointWOfBOXGivenPointW( b2, temp);
//----------------------
//let us find out if there was an intersection
// <==> voronoiTemp = temp, because it would means that the projected point is already the closest to b2 for it is within it.
if( equals(voronoiTemp,temp,precision) )
{
//let us refill pointsB1 with it :
pointsB1.set( temp.get(1,1), 1,col);
pointsB1.set( temp.get(2,1), 2,col);
pointsB1.set( temp.get(3,1), 3,col);
if(initialized)
{
ret = operatorL( ret, temp);
}
else
{
initialized = true;
ret = temp;
}
intersect = true;
#ifdef debug
std::cout << "COLLISION DETECTOR : midnarrowphase : testOBBOBB : voronoi and temp : " << std::endl;
std::cout << " ids : b1 = " << b1.getID() << " ; b2 = " << b2.getID() << std::endl;
operatorL(voronoiTemp,temp).afficher();
//std::cout << "COLLISION POINTS :" << std::endl;
//ret.afficher();
//tempL.afficher();
#endif
}
else
{
#ifdef debug
std::cout << "COLLISION DETECTOR : ELSE : midnarrowphase : testOBBOBB : voronoi and temp : " << std::endl;
std::cout << " ids : b1 = " << b1.getID() << " ; b2 = " << b2.getID() << std::endl;
operatorL(voronoiTemp,temp).afficher();
//std::cout << "COLLISION POINTS :" << std::endl;
//ret.afficher();
//tempL.afficher();
#endif
}
col++;
}
}
}
return ret;
}
/* prepare list for fast lookups */
fastlist_t *prepare_fastlist (char **list)
{
int i, j, current_category, negation, escaped, first_special;
fastlist_t *fl;
char *p, *p1;
fl = xmalloc (sizeof(fastlist_t));
/* count total number of rules. we add fictitios rule at the start
to avoid having rule #0 which is bad for routines which use
signed integers to indicate positive/negative matches */
for (i=0; list[i] != NULL; i++)
;
fl->n = i+1;
fl->ncats = 0;
fl->rules = xmalloc (sizeof(catrule_t) * fl->n);
fl->rules[0].type = RULETYPE_SEPARATOR;
fl->rules[0].category = 0;
fl->rules[0].rule = NULL;
fl->rules[0].len = 0;
/* process every rule: assign type, possibly convert */
current_category = 0;
for (i=1; i<fl->n; i++)
{
/* shifted because we inserted one rule! */
p = list[i-1];
/* check for separator */
if (p[0] == '+')
{
p++;
p1 = strchr (p, ' ');
if (p1 != NULL) *p1 = '\0';
current_category = atoi (p);
if (current_category != 0) fl->ncats++;
if (p1 != NULL) *p1 = ' ';
fl->rules[i].type = RULETYPE_SEPARATOR;
fl->rules[i].category = 0;
fl->rules[i].rule = NULL;
fl->rules[i].len = 0;
continue;
}
/* check for subcategories list */
if (p[0] == ':')
{
fl->rules[i].type = RULETYPE_SUBCATS;
fl->rules[i].rule = strdup (p+1);
fl->rules[i].category = current_category;
continue;
}
/* check for negation */
if (p[0] == '^')
{
p++;
negation = TRUE;
}
else
negation = FALSE;
/* if rule does not contain slashes at all, append one at the
end */
if (strchr (p, '/') == NULL)
{
p = str_join (p, "/*");
}
/* see if this rule is simple, exact or complex: lookup
special chars *, ?, [ */
escaped = FALSE;
first_special = -1;
for (j=0; p[j] != '\0'; j++)
{
switch (p[j])
{
case '\\':
if (!escaped) escaped = TRUE;
break;
case '?':
case '*':
case '[':
if (!escaped) first_special = j;
else escaped = FALSE;
break;
default:
if (escaped) escaped = FALSE;
}
if (first_special != -1) break;
}
/* no special chars at all? */
if (first_special == -1)
{
if (negation)
fl->rules[i].type = RULETYPE_MATCH_NEG;
else
fl->rules[i].type = RULETYPE_MATCH;
fl->rules[i].rule = strdup (p);
kill_escapes (fl->rules[i].rule);
}
/* simple rule? (just asterisk at the end) */
else if (p[first_special] == '*' && p[first_special+1] == '\0')
{
if (negation)
fl->rules[i].type = RULETYPE_SIMPLE_NEG;
else
fl->rules[i].type = RULETYPE_SIMPLE;
fl->rules[i].rule = strdup (p);
fl->rules[i].rule[first_special] = '\0';
kill_escapes (fl->rules[i].rule);
}
/* everything else is complex */
else
{
if (negation)
fl->rules[i].type = RULETYPE_COMPLEX_NEG;
else
fl->rules[i].type = RULETYPE_COMPLEX;
fl->rules[i].rule = strdup (p);
}
fl->rules[i].category = current_category;
fl->rules[i].len = strlen (fl->rules[i].rule);
}
/* build a sorted list of simple and exact rules. find out
the shortest rule among them */
fl->n_simple = 0;
fl->n_complex = 0;
for (i=0; i<fl->n; i++)
{
if (fl->rules[i].type == RULETYPE_MATCH ||
fl->rules[i].type == RULETYPE_SIMPLE ||
fl->rules[i].type == RULETYPE_MATCH_NEG ||
fl->rules[i].type == RULETYPE_SIMPLE_NEG)
fl->n_simple++;
else if (fl->rules[i].type == RULETYPE_COMPLEX ||
fl->rules[i].type == RULETYPE_COMPLEX_NEG)
fl->n_complex++;
}
if (fl->n_simple > 0)
fl->simple = xmalloc (sizeof(int) * fl->n_simple);
if (fl->n_complex > 0)
fl->complex = xmalloc (sizeof(int) * fl->n_complex);
fl->n_simple = 0;
fl->n_complex = 0;
fl->shortest = 10000000;
/* j = 0; */
for (i=0; i<fl->n; i++)
{
if (fl->rules[i].type == RULETYPE_MATCH ||
fl->rules[i].type == RULETYPE_SIMPLE ||
fl->rules[i].type == RULETYPE_MATCH_NEG ||
fl->rules[i].type == RULETYPE_SIMPLE_NEG)
{
fl->shortest = min1 (fl->shortest, strlen(fl->rules[i].rule));
fl->simple[fl->n_simple++] = i;
}
else if (fl->rules[i].type == RULETYPE_COMPLEX ||
fl->rules[i].type == RULETYPE_COMPLEX_NEG)
{
fl->complex[fl->n_complex++] = i;
}
/* if (fl->rules[i].type == RULETYPE_SEPARATOR) j = i+1; */
}
fl1 = fl;
qsort (fl->simple, fl->n_simple, sizeof(int), cmp_simple);
return fl;
}
///
//Performs a dynamic collision check between a moving AABB and a static AABB.
//
//Overview:
// This algorithm detects potentially missed collisions by performing a moving version of the
// separating axis test. First we must determine the distances along each axis signifying
// the distance to begin collision (dFirst) & the distance to separate from that collision (dLast). Then
// we can easily determine the time at which these distances will be reached by dividing them by the magnitude of the
// velocity along the axis (tFirst / tLast). If we keep the largest tFirst and the smallest tLast from all axes,
// we will determine the time interval which the boxes will be intersecting! If tLast < tFirst, the boxes will not overlap.
// Alternatively, if tFirst > 1.0f, the boxes will not overlap!
//
//Parameters:
// aabb1: The moving aabb
// aabb2: The static aabb
// mvmt: The relative movement vector of box 1 from an observer on box 2
//
//Returns:
// a t value between 0 and 1 indicating the "relative time" since the start of this frame that the collision occurred.
// a t value of 0.0f would indicate the very start of this frame, a t value of 1.0f would indicate the very end of this frame.
float CheckDynamicCollision(const AABB &aabb1, const AABB &aabb2, const glm::vec3 &mvmt)
{
//If we start out colliding, we do not need to perform the test.
if (CheckCollision(aabb1, aabb2))
{
return 0.0f;
}
float tFirst = 0.0f;
float tLast = 1.0f;
float tCurrent = 0.0f;
//Get the minimum and maximum dimensions in world space for each box
glm::vec2 min1(aabb1.center - (aabb1.dimensions*0.5f));
glm::vec2 max1(aabb1.center + (aabb1.dimensions*0.5f));
glm::vec2 min2(aabb2.center - (aabb2.dimensions*0.5f));
glm::vec2 max2(aabb2.center + (aabb2.dimensions*0.5f));
//For every axis (X, and Y axes in this case)
for (int i = 0; i < 3; i++)
{
//Check the direction of the projection of the movement vector on this axis
if (mvmt[i] < 0.0f)
{
//In this case object 1 is moving in the negative direction along axis from an observer on object 2.
//So if object 1 is more negative in direction than object 2, they will not collide on this axis.
if (max1[i] < min2[i]) return -1.0f;
//Is the "low part" object 1 higher than the "high part" object 2 along this axis?
if (min1[i] > max2[i])
{
//If so, the shapes are not yet colliding on this axis, so determine when they first will collide on this axis
tCurrent = (max2[i] - min1[i]) / mvmt[i]; //We solve for a negative distance here, because we are dividing by a negative velocity to get a positive time
//This strange ordering prevents us from needing to make a call to fabs (absolute value function)
//If it is larger than the current tFirst, change tFirst
if (tCurrent > tFirst) tFirst = tCurrent;
}
//Is the "High Part" of object 1 higher than the low part of object 2 along this axis?
if (max1[i] > min2[i])
{
//If so, the shapes have not yet separated on this axis, so determine when they will finish colliding
tCurrent = (min2[i] - max1[i]) / mvmt[i]; //Note the wierd ordering again, for the same reason as above
//If it is smaller than current tLast, update tLast
if (tCurrent < tLast) tLast = tCurrent;
}
}
else if (mvmt[i] > 0.0f)
{
//If object 1 is more positive along the axis than object 2, they will not collide
if (min1[i] > max2[i]) return -1.0f;
//Is the "High part" of object 1 lower than the "low part" of object 2 along this axis?
if (max1[i] < min2[i])
{
//If so, the shapes are not yet colliding on this axis so determine when they will first collide on this axis
tCurrent = (min2[i] - max1[i]) / mvmt[i];
//If it is larger than the current tFirst, update tFirst
if (tCurrent > tFirst) tFirst = tCurrent;
}
//Is the "Low part" of object 1 lower than the "high part" of object 2 along this axis?
if (min1[i] < max2[i])
{
//If so, the shapes have not yet separated on this axis, so determine when they will finish collidiing
tCurrent = (max2[i] - min1[i]) / mvmt[i];
//If it is smaller than the current tLast, update tLast
if (tCurrent < tLast) tLast = tCurrent;
}
}
}
//If there was no overlap
if (tLast < tFirst) return -1.0f;
return tFirst;
}
std::array<unsigned long,vcp<4,1,1>::element_count()> const vcp<4,1,1>::generate_vector( const_vertex_iterator v1, const_vertex_iterator v2 ) {
std::array<unsigned long,element_count()> counts = {{0}};
std::size_t v1v2( V1V2 * OUT * g.out_edge_exists( v1, v2 ) + V1V2 * IN * g.in_edge_exists( v1, v2 ) );
unsigned long connections( 0 );
unsigned long amutuals( 0 );
unsigned long gaps( 0 );
// compose ordered list of v3 candidates
const_edge_iterator v1_out_neighbors_it( g.out_neighbors_begin( v1 ) );
const_edge_iterator v1_out_neighbors_end( g.out_neighbors_end( v1 ) );
const_edge_iterator v1_in_neighbors_it( g.in_neighbors_begin( v1 ) );
const_edge_iterator v1_in_neighbors_end( g.in_neighbors_end( v1 ) );
const_edge_iterator v2_out_neighbors_it( g.out_neighbors_begin( v2 ) );
const_edge_iterator v2_out_neighbors_end( g.out_neighbors_end( v2 ) );
const_edge_iterator v2_in_neighbors_it( g.in_neighbors_begin( v2 ) );
const_edge_iterator v2_in_neighbors_end( g.in_neighbors_end( v2 ) );
assert( MAX_NEIGHBORS > (v1_out_neighbors_end-v1_out_neighbors_it)+(v1_in_neighbors_end-v1_in_neighbors_it)+(v2_out_neighbors_end-v2_out_neighbors_it)+(v2_in_neighbors_end-v2_in_neighbors_it) );
std::pair<const_vertex_iterator,unsigned short>* v3Vertices_begin( &v3Vertices[0] );
std::pair<const_vertex_iterator,unsigned short>* v3Vertices_end( &v3Vertices[0] );
std::pair<const_edge_iterator,directedness_value> min1( next_union_element( v1_out_neighbors_it, v1_out_neighbors_end, v1_in_neighbors_it, v1_in_neighbors_end ) );
std::pair<const_edge_iterator,directedness_value> min2( next_union_element( v2_out_neighbors_it, v2_out_neighbors_end, v2_in_neighbors_it, v2_in_neighbors_end ) );
while( min1.first != v1_in_neighbors_end && min2.first != v2_in_neighbors_end ) {
if( g.target_of( min1.first ) < g.target_of( min2.first ) ) {
if( g.target_of( min1.first ) != v2 ) {
++connections;
++gaps;
if( min1.second < 3 ) {
++amutuals;
}
v3Vertices_end->first = g.target_of( min1.first );
v3Vertices_end->second = v1v2 + V1V3 * min1.second;
++v3Vertices_end;
}
min1 = next_union_element( v1_out_neighbors_it, v1_out_neighbors_end, v1_in_neighbors_it, v1_in_neighbors_end );
} else if( g.target_of( min1.first ) > g.target_of( min2.first ) ) {
if( g.target_of( min2.first ) != v1 ) {
++connections;
++gaps;
if( min2.second < 3 ) {
++amutuals;
}
v3Vertices_end->first = g.target_of( min2.first );
v3Vertices_end->second = v1v2 + V2V3 * min2.second;
++v3Vertices_end;
}
min2 = next_union_element( v2_out_neighbors_it, v2_out_neighbors_end, v2_in_neighbors_it, v2_in_neighbors_end );
} else { // the next neighbor is shared by both v1 and v2, so it cannot be either and we do not need to check to exclude it
connections += 2;
if( min1.second < 3 ) {
++amutuals;
}
if( min2.second < 3 ) {
++amutuals;
}
v3Vertices_end->first = g.target_of( min1.first );
v3Vertices_end->second = v1v2 + V1V3 * min1.second + V2V3 * min2.second;
++v3Vertices_end;
min1 = next_union_element( v1_out_neighbors_it, v1_out_neighbors_end, v1_in_neighbors_it, v1_in_neighbors_end );
min2 = next_union_element( v2_out_neighbors_it, v2_out_neighbors_end, v2_in_neighbors_it, v2_in_neighbors_end );
}
}
while( min1.first != v1_in_neighbors_end ) {
if( g.target_of( min1.first ) != v2 ) {
++connections;
++gaps;
if( min1.second < 3 ) {
++amutuals;
}
v3Vertices_end->first = g.target_of( min1.first );
v3Vertices_end->second = v1v2 + V1V3 * min1.second;
++v3Vertices_end;
}
min1 = next_union_element( v1_out_neighbors_it, v1_out_neighbors_end, v1_in_neighbors_it, v1_in_neighbors_end );
}
while( min2.first != v2_in_neighbors_end ) {
if( g.target_of( min2.first ) != v1 ) {
++connections;
++gaps;
if( min2.second < 3 ) {
++amutuals;
}
v3Vertices_end->first = g.target_of( min2.first );
v3Vertices_end->second = v1v2 + V2V3 * min2.second;
++v3Vertices_end;
}
min2 = next_union_element( v2_out_neighbors_it, v2_out_neighbors_end, v2_in_neighbors_it, v2_in_neighbors_end );
}
unsigned long v3_count( v3Vertices_end-v3Vertices_begin );
unsigned long v4_count( 0 );
for( std::pair<const_vertex_iterator,unsigned short>* it1( v3Vertices_begin ); it1 != v3Vertices_end; ++it1 ) { // for each v3 vertex computed above
const_edge_iterator v3_out_neighbors_it( g.out_neighbors_begin( it1->first ) );
const_edge_iterator v3_out_neighbors_end( g.out_neighbors_end( it1->first ) );
const_edge_iterator v3_in_neighbors_it( g.in_neighbors_begin( it1->first ) );
const_edge_iterator v3_in_neighbors_end( g.in_neighbors_end( it1->first ) );
unsigned long v4_local_count( 0 ); // keep track of how many v4 vertices are only the result of the neighbors of this v3
std::pair<const_edge_iterator,directedness_value> min( next_union_element( v3_out_neighbors_it, v3_out_neighbors_end, v3_in_neighbors_it, v3_in_neighbors_end ) );
for( std::pair<const_vertex_iterator,unsigned short>* it2( v3Vertices_begin ); it2 != v3Vertices_end; ++it2 ) {
while( min.first != v3_in_neighbors_end && g.target_of( min.first ) < it2->first ) {
if( g.target_of( min.first ) != v1 && g.target_of( min.first ) != v2 ) {
++v4_local_count;
if( min.second < 3 ) {
++amutuals;
}
++counts[ element_address( it1->second + V3V4 * min.second ) ];
}
min = next_union_element( v3_out_neighbors_it, v3_out_neighbors_end, v3_in_neighbors_it, v3_in_neighbors_end );
}
if( min.first == v3_in_neighbors_end || g.target_of( min.first ) > it2->first ) {
if( it1->first < it2->first ) {
unsigned short temp( it2->second - v1v2 );
std::size_t contrib( 0 );
contrib += V1V4 * (temp % V2V3);
contrib += V2V4 * (temp / V2V3);
++gaps;
++counts[ element_address( it1->second + contrib ) ];
}
} else {
if( it1->first < it2->first ) {
unsigned short temp( it2->second - v1v2 );
std::size_t contrib( 0 );
contrib += V1V4 * (temp % V2V3);
contrib += V2V4 * (temp / V2V3);
++connections;
if( min.second < 3 ) {
++amutuals;
}
++counts[ element_address( it1->second + contrib + V3V4 * min.second ) ];
}
min = next_union_element( v3_out_neighbors_it, v3_out_neighbors_end, v3_in_neighbors_it, v3_in_neighbors_end );
}
}
while( min.first != v3_in_neighbors_end ) {
if( g.target_of( min.first ) != v1 && g.target_of( min.first ) != v2 ) {
++v4_local_count;
if( min.second < 3 ) {
++amutuals;
}
++counts[ element_address( it1->second + V3V4 * min.second ) ];
}
min = next_union_element( v3_out_neighbors_it, v3_out_neighbors_end, v3_in_neighbors_it, v3_in_neighbors_end );
}
v4_count += v4_local_count;
connections += v4_local_count;
gaps += 2*v4_local_count;
counts[ element_address( it1->second ) ] += g.vertex_count() - 2 - v3_count - v4_local_count;
}
// account for the least connected substructures
counts[ element_address( v1v2+OUT*V3V4) ] = this->amutualPairs - (amutuals + static_cast<bool>(v1v2)); // out and in versions are isomorphically equivalent and do not need to be counted separately
counts[ element_address( v1v2+BOTH*V3V4 ) ] = this->mutualPairs - (connections - amutuals);
counts[ element_address( v1v2 ) ] = unconnected_pairs - (gaps + !static_cast<bool>(v1v2)) - (2 + v3_count) * (g.vertex_count() - 2 - v3_count) + 3 * v4_count;
return counts;
}
int IL_resample_interp_segments_2d(struct interp_params *params, struct BM *bitmask, /* bitmask */
double zmin, double zmax, /* min and max input z-values */
double *zminac, double *zmaxac, /* min and max interp. z-values */
double *gmin, double *gmax, /* min and max inperp. slope val. */
double *c1min, double *c1max, double *c2min, double *c2max, /* min and max interp. curv. val. */
double *ertot, /* total interplating func. error */
off_t offset1, /* offset for temp file writing */
double *dnorm,
int overlap,
int inp_rows,
int inp_cols,
int fdsmooth,
int fdinp,
double ns_res,
double ew_res,
double inp_ns_res,
double inp_ew_res, int dtens)
{
int i, j, k, l, m, m1, i1; /* loop coounters */
int cursegm = 0;
int new_comp = 0;
int n_rows, n_cols, inp_r, inp_c;
double x_or, y_or, xm, ym;
static int first = 1, new_first = 1;
double **matrix = NULL, **new_matrix = NULL, *b = NULL;
int *indx = NULL, *new_indx = NULL;
static struct fcell_triple *in_points = NULL; /* input points */
int inp_check_rows, inp_check_cols, /* total input rows/cols */
out_check_rows, out_check_cols; /* total output rows/cols */
int first_row, last_row; /* first and last input row of segment */
int first_col, last_col; /* first and last input col of segment */
int num, prev;
int div; /* number of divides */
int rem_out_row, rem_out_col; /* output rows/cols remainders */
int inp_seg_r, inp_seg_c, /* # of input rows/cols in segment */
out_seg_r, out_seg_c; /* # of output rows/cols in segment */
int ngstc, nszc /* first and last output col of the
* segment */
, ngstr, nszr; /* first and last output row of the
* segment */
int index; /* index for input data */
int c, r;
int overlap1;
int p_size;
struct quaddata *data;
double xmax, xmin, ymax, ymin;
int totsegm; /* total number of segments */
int total_points = 0;
struct triple triple; /* contains garbage */
xmin = params->x_orig;
ymin = params->y_orig;
xmax = xmin + ew_res * params->nsizc;
ymax = ymin + ns_res * params->nsizr;
prev = inp_rows * inp_cols;
if (prev <= params->kmax)
div = 1; /* no segmentation */
else { /* find the number of divides */
for (i = 2;; i++) {
c = inp_cols / i;
r = inp_rows / i;
num = c * r;
if (num < params->kmin) {
if (((params->kmin - num) > (prev + 1 - params->kmax)) &&
(prev + 1 < params->KMAX2)) {
div = i - 1;
break;
}
else {
div = i;
break;
}
}
if ((num > params->kmin) && (num + 1 < params->kmax)) {
div = i;
break;
}
prev = num;
}
}
out_seg_r = params->nsizr / div; /* output rows per segment */
out_seg_c = params->nsizc / div; /* output cols per segment */
inp_seg_r = inp_rows / div; /* input rows per segment */
inp_seg_c = inp_cols / div; /* input rows per segment */
rem_out_col = params->nsizc % div;
rem_out_row = params->nsizr % div;
overlap1 = min1(overlap, inp_seg_c - 1);
overlap1 = min1(overlap1, inp_seg_r - 1);
out_check_rows = 0;
out_check_cols = 0;
inp_check_rows = 0;
inp_check_cols = 0;
if (div == 1) {
p_size = inp_seg_c * inp_seg_r;
}
else {
p_size = (overlap1 * 2 + inp_seg_c) * (overlap1 * 2 + inp_seg_r);
}
if (!in_points) {
if (!
(in_points =
(struct fcell_triple *)G_malloc(sizeof(struct fcell_triple) *
p_size * div))) {
fprintf(stderr, "Cannot allocate memory for in_points\n");
return -1;
}
}
*dnorm =
sqrt(((xmax - xmin) * (ymax -
ymin) * p_size) / (inp_rows * inp_cols));
if (dtens) {
params->fi = params->fi * (*dnorm) / 1000.;
fprintf(stderr, "dnorm = %f, rescaled tension = %f\n", *dnorm,
params->fi);
}
if (div == 1) { /* no segmentation */
totsegm = 1;
cursegm = 1;
input_data(params, 1, inp_rows, in_points, fdsmooth, fdinp, inp_rows,
inp_cols, zmin, inp_ns_res, inp_ew_res);
x_or = 0.;
y_or = 0.;
xm = params->nsizc * ew_res;
ym = params->nsizr * ns_res;
data = (struct quaddata *)quad_data_new(x_or, y_or, xm, ym,
params->nsizr, params->nsizc,
0, params->KMAX2);
m1 = 0;
for (k = 1; k <= p_size; k++) {
if (!Rast_is_f_null_value(&(in_points[k - 1].z))) {
data->points[m1].x = in_points[k - 1].x / (*dnorm);
data->points[m1].y = in_points[k - 1].y / (*dnorm);
/* data->points[m1].z = (double) (in_points[k - 1].z) / (*dnorm); */
data->points[m1].z = (double)(in_points[k - 1].z);
data->points[m1].sm = in_points[k - 1].smooth;
m1++;
}
}
data->n_points = m1;
total_points = m1;
if (!(indx = G_alloc_ivector(params->KMAX2 + 1))) {
fprintf(stderr, "Cannot allocate memory for indx\n");
return -1;
}
if (!(matrix = G_alloc_matrix(params->KMAX2 + 1, params->KMAX2 + 1))) {
fprintf(stderr, "Cannot allocate memory for matrix\n");
return -1;
}
if (!(b = G_alloc_vector(params->KMAX2 + 2))) {
fprintf(stderr, "Cannot allocate memory for b\n");
return -1;
}
if (params->matrix_create(params, data->points, m1, matrix, indx) < 0)
return -1;
for (i = 0; i < m1; i++) {
b[i + 1] = data->points[i].z;
}
b[0] = 0.;
G_lubksb(matrix, m1 + 1, indx, b);
params->check_points(params, data, b, ertot, zmin, *dnorm, triple);
if (params->grid_calc(params, data, bitmask,
zmin, zmax, zminac, zmaxac, gmin, gmax,
c1min, c1max, c2min, c2max, ertot, b, offset1,
*dnorm) < 0) {
fprintf(stderr, "interpolation failed\n");
return -1;
}
else {
if (totsegm != 0) {
G_percent(cursegm, totsegm, 1);
}
/*
* if (b) G_free_vector(b); if (matrix) G_free_matrix(matrix); if
* (indx) G_free_ivector(indx);
*/
fprintf(stderr, "dnorm in ressegm after grid before out= %f \n",
*dnorm);
return total_points;
}
}
out_seg_r = params->nsizr / div; /* output rows per segment */
out_seg_c = params->nsizc / div; /* output cols per segment */
inp_seg_r = inp_rows / div; /* input rows per segment */
inp_seg_c = inp_cols / div; /* input rows per segment */
rem_out_col = params->nsizc % div;
rem_out_row = params->nsizr % div;
overlap1 = min1(overlap, inp_seg_c - 1);
overlap1 = min1(overlap1, inp_seg_r - 1);
out_check_rows = 0;
out_check_cols = 0;
inp_check_rows = 0;
inp_check_cols = 0;
totsegm = div * div;
/* set up a segment */
for (i = 1; i <= div; i++) { /* input and output rows */
if (i <= div - rem_out_row)
n_rows = out_seg_r;
else
n_rows = out_seg_r + 1;
inp_r = inp_seg_r;
out_check_cols = 0;
inp_check_cols = 0;
ngstr = out_check_rows + 1; /* first output row of the segment */
nszr = ngstr + n_rows - 1; /* last output row of the segment */
y_or = (ngstr - 1) * ns_res; /* y origin of the segment */
/*
* Calculating input starting and ending rows and columns of this
* segment
*/
first_row = (int)(y_or / inp_ns_res) + 1;
if (first_row > overlap1) {
first_row -= overlap1; /* middle */
last_row = first_row + inp_seg_r + overlap1 * 2 - 1;
if (last_row > inp_rows) {
first_row -= (last_row - inp_rows); /* bottom */
last_row = inp_rows;
}
}
else {
first_row = 1; /* top */
last_row = first_row + inp_seg_r + overlap1 * 2 - 1;
}
if ((last_row > inp_rows) || (first_row < 1)) {
fprintf(stderr, "Row overlap too large!\n");
return -1;
}
input_data(params, first_row, last_row, in_points, fdsmooth, fdinp,
inp_rows, inp_cols, zmin, inp_ns_res, inp_ew_res);
for (j = 1; j <= div; j++) { /* input and output cols */
if (j <= div - rem_out_col)
n_cols = out_seg_c;
else
n_cols = out_seg_c + 1;
inp_c = inp_seg_c;
ngstc = out_check_cols + 1; /* first output col of the segment */
nszc = ngstc + n_cols - 1; /* last output col of the segment */
x_or = (ngstc - 1) * ew_res; /* x origin of the segment */
first_col = (int)(x_or / inp_ew_res) + 1;
if (first_col > overlap1) {
first_col -= overlap1; /* middle */
last_col = first_col + inp_seg_c + overlap1 * 2 - 1;
if (last_col > inp_cols) {
first_col -= (last_col - inp_cols); /* right */
last_col = inp_cols;
}
}
else {
first_col = 1; /* left */
last_col = first_col + inp_seg_c + overlap1 * 2 - 1;
}
if ((last_col > inp_cols) || (first_col < 1)) {
fprintf(stderr, "Column overlap too large!\n");
return -1;
}
m = 0;
/* Getting points for interpolation (translated) */
xm = nszc * ew_res;
ym = nszr * ns_res;
data = (struct quaddata *)quad_data_new(x_or, y_or, xm, ym,
nszr - ngstr + 1,
nszc - ngstc + 1, 0,
params->KMAX2);
new_comp = 0;
for (k = 0; k <= last_row - first_row; k++) {
for (l = first_col - 1; l < last_col; l++) {
index = k * inp_cols + l;
if (!Rast_is_f_null_value(&(in_points[index].z))) {
/* if the point is inside the segment (not overlapping) */
if ((in_points[index].x - x_or >= 0) &&
(in_points[index].y - y_or >= 0) &&
((nszc - 1) * ew_res - in_points[index].x >= 0) &&
((nszr - 1) * ns_res - in_points[index].y >= 0))
total_points += 1;
data->points[m].x =
(in_points[index].x - x_or) / (*dnorm);
data->points[m].y =
(in_points[index].y - y_or) / (*dnorm);
/* data->points[m].z = (double) (in_points[index].z) / (*dnorm); */
data->points[m].z = (double)(in_points[index].z);
data->points[m].sm = in_points[index].smooth;
m++;
}
else
new_comp = 1;
/* fprintf(stderr,"%f,%f,%f
zmin=%f\n",in_points[index].x,in_points[index].y,in_points[index].z,zmin);
*/
}
}
/* fprintf (stdout,"m,index:%di,%d\n",m,index); */
if (m <= params->KMAX2)
data->n_points = m;
else
data->n_points = params->KMAX2;
out_check_cols += n_cols;
inp_check_cols += inp_c;
cursegm = (i - 1) * div + j - 1;
/* show before to catch 0% */
if (totsegm != 0) {
G_percent(cursegm, totsegm, 1);
}
if (m == 0) {
/*
* fprintf(stderr,"Warning: segment with zero points encountered,
* insrease overlap\n");
*/
write_zeros(params, data, offset1);
}
else {
if (new_comp) {
if (new_first) {
new_first = 0;
if (!b) {
if (!(b = G_alloc_vector(params->KMAX2 + 2))) {
fprintf(stderr,
"Cannot allocate memory for b\n");
return -1;
}
}
if (!(new_indx = G_alloc_ivector(params->KMAX2 + 1))) {
fprintf(stderr,
"Cannot allocate memory for new_indx\n");
return -1;
}
if (!
(new_matrix =
G_alloc_matrix(params->KMAX2 + 1,
params->KMAX2 + 1))) {
fprintf(stderr,
"Cannot allocate memory for new_matrix\n");
return -1;
}
} /*new_first */
if (params->
matrix_create(params, data->points, data->n_points,
new_matrix, new_indx) < 0)
return -1;
for (i1 = 0; i1 < m; i1++) {
b[i1 + 1] = data->points[i1].z;
}
b[0] = 0.;
G_lubksb(new_matrix, data->n_points + 1, new_indx, b);
params->check_points(params, data, b, ertot, zmin,
*dnorm, triple);
if (params->grid_calc(params, data, bitmask,
zmin, zmax, zminac, zmaxac, gmin,
gmax, c1min, c1max, c2min, c2max,
ertot, b, offset1, *dnorm) < 0) {
fprintf(stderr, "interpolate() failed\n");
return -1;
}
} /*new_comp */
else {
if (first) {
first = 0;
if (!b) {
if (!(b = G_alloc_vector(params->KMAX2 + 2))) {
fprintf(stderr,
"Cannot allocate memory for b\n");
return -1;
}
}
if (!(indx = G_alloc_ivector(params->KMAX2 + 1))) {
fprintf(stderr,
"Cannot allocate memory for indx\n");
return -1;
}
if (!
(matrix =
G_alloc_matrix(params->KMAX2 + 1,
params->KMAX2 + 1))) {
fprintf(stderr,
"Cannot allocate memory for matrix\n");
return -1;
}
} /* first */
if (params->
matrix_create(params, data->points, data->n_points,
matrix, indx) < 0)
return -1;
/* } here it was bug */
for (i1 = 0; i1 < m; i1++)
b[i1 + 1] = data->points[i1].z;
b[0] = 0.;
G_lubksb(matrix, data->n_points + 1, indx, b);
params->check_points(params, data, b, ertot, zmin,
*dnorm, triple);
if (params->grid_calc(params, data, bitmask,
zmin, zmax, zminac, zmaxac, gmin,
gmax, c1min, c1max, c2min, c2max,
ertot, b, offset1, *dnorm) < 0) {
fprintf(stderr, "interpolate() failed\n");
return -1;
}
}
}
if (data) {
G_free(data->points);
G_free(data);
}
/*
* cursegm++;
*/
}
inp_check_rows += inp_r;
out_check_rows += n_rows;
}
/* run one last time after the loop is done to catch 100% */
if (totsegm != 0)
G_percent(1, 1, 1); /* cursegm doesn't get to totsegm so we force 100% */
/*
* if (b) G_free_vector(b); if (indx) G_free_ivector(indx); if (matrix)
* G_free_matrix(matrix);
*/
fprintf(stderr, "dnorm in ressegm after grid before out2= %f \n", *dnorm);
return total_points;
}
int main(int argc, char **argv) {
MPI_Init(&argc, &argv);
QUESO::EnvOptionsValues options;
options.m_numSubEnvironments = 1;
options.m_subDisplayFileName = "outputData/testIntersectionSubsetContains";
options.m_subDisplayAllowAll = 0;
options.m_subDisplayAllowedSet.insert(0);
options.m_seed = 1.0;
options.m_checkingLevel = 1;
options.m_displayVerbosity = 55;
QUESO::FullEnvironment *env = new QUESO::FullEnvironment(MPI_COMM_WORLD, "",
"", &options);
std::vector<std::string> names(1);
names[0] = "my_name";
// Create a vector space
QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix> vec_space(*env,
"vec_prefix", 1, &names);
// Create two vector sets
QUESO::GslVector min1(vec_space.zeroVector());
min1[0] = 0.0;
QUESO::GslVector max1(vec_space.zeroVector());
max1[0] = 1.0;
QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> set1("set1", vec_space,
min1, max1);
// Now for the second one
QUESO::GslVector min2(vec_space.zeroVector());
min2[0] = 0.5;
QUESO::GslVector max2(vec_space.zeroVector());
max2[0] = 1.5;
QUESO::BoxSubset<QUESO::GslVector, QUESO::GslMatrix> set2("set1", vec_space,
min2, max2);
// Create their intersection
QUESO::IntersectionSubset<QUESO::GslVector, QUESO::GslMatrix> intersection(
"intersection", vec_space, 1.0, set1, set2);
// Test the containment
bool does_contain;
QUESO::GslVector test_vec(vec_space.zeroVector());
// Should be true
test_vec[0] = 0.75;
does_contain = intersection.contains(test_vec);
if (!does_contain) {
std::cerr << "First IntersectionSubset contains test failed" << std::endl;
return 1;
}
// Should be false
test_vec[0] = 2.0;
does_contain = intersection.contains(test_vec);
if (does_contain) {
std::cerr << "Second contains test failed" << std::endl;
return 1;
}
// Print out some info
intersection.print(std::cout);
MPI_Finalize();
return 0;
}
void editor (char *filename, int startpos)
{
int stop = FALSE; // exit main loop?
int fline = 0; // no. of first displayed line
int cline = 0; // no. of line with cursor
int shift = 0; // shift to the right
int ccol = 0; // column of the cursor position in the file window
int k, i, ndisp, rc, reply;
char *p, buf[1024];
if (editor_open_file (filename) < 0) return;
cline = min1 (startpos, nl-1);
fline = max1 (0, cline - video_vsize()/2);
// enter the loop
while (1)
{
if (stop)
{
rc = 0;
if (changed)
{
rc = -1;
reply = fly_ask (0, " Save file `%s'? ", " Yes \n No \n Cancel ", filename);
if (reply == 1) rc = editor_save_file (filename);
if (reply == 2) rc = 0;
if (reply == 3) stop = FALSE;
}
if (rc == 0) break;
}
ndisp = video_vsize()-1;
// draw the screen
for (i=0; i<ndisp; i++)
{
video_put_n_cell (' ', _BackWhite+_Black, video_hsize(), i, 0);
if (i+fline < nl)
editor_display_line (i, fline+i, shift);
}
video_put_n_cell (' ', _BackBlue+_White, video_hsize(), video_vsize()-1, 0);
snprintf1 (buf, sizeof(buf), "L%d:C%d:S%d %c %s%s", cline, ccol, shift, fl_sym.v,
changed ? "*" : "", filename);
video_put (buf, video_vsize()-1, 0);
video_set_cursor (cline-fline, ccol-shift);
video_update (0);
// get a keyboard/mouse event and process it
k = getmessage (-1);
if (IS_KEY(k))
{
switch (k)
{
// Navigation keys
case _Up:
case _Down:
case _PgUp:
case _PgDn:
fly_scroll_it (k, &fline, &cline, nl, video_vsize()-1);
break;
case _Right:
ccol++;
if (ccol-shift > video_hsize()-1) shift = ccol-video_hsize()+1;
break;
case _Left:
ccol = max1 (ccol-1, 0);
if (ccol < shift) shift = ccol;
break;
case _Home:
ccol = 0; shift = 0;
break;
case _End:
ccol = strlen(lines[cline]);
if (ccol-shift > video_hsize()-1) shift = ccol-video_hsize()+1;
break;
case _CtrlHome:
fline = 0; cline = 0; ccol = 0; shift = 0; break;
case _CtrlEnd:
fline = max1 (0, nl-video_vsize()+1);
cline = min1 (fline+video_vsize()-1, nl-1);
shift = 0;
ccol = 0;
break;
// Action keys
case _CtrlY:
put_clipboard (lines[cline]);
free (lines[cline]);
for (i=cline; i<nl-1; i++)
lines[i] = lines[i+1];
nl--;
changed = TRUE;
break;
case _ShiftInsert:
case _CtrlV:
p = get_clipboard ();
if (p == NULL || *p == '\0') break;
if (nl == na)
{
na *= 2;
lines = realloc (lines, sizeof(char *) * na);
}
for (i=nl-1; i>cline; i--)
lines[i+1] = lines[i];
lines[cline+1] = p;
ccol = 0;
shift = 0;
cline++;
if (cline-fline == video_vsize()-1) fline++;
nl++;
changed = TRUE;
break;
case _BackSpace:
if (ccol == 0)
{
// ccol == 0: glue this line to the previous
if (cline == 0) break;
p = malloc (strlen (lines[cline])+strlen(lines[cline-1])+1);
strcpy (p, lines[cline-1]);
strcat (p, lines[cline]);
ccol = strlen (lines[cline-1]);
if (ccol-shift > video_hsize()-1) shift = ccol-video_hsize()+1;
free (lines[cline-1]);
free (lines[cline]);
lines[cline-1] = p;
for (i=cline; i<nl-1; i++)
lines[i] = lines[i+1];
cline--;
nl--;
}
else
{
// ccol != 0: delete char at ccol-1, move cursor left
str_delete (lines[cline], lines[cline]+ccol-1);
ccol--;
if (ccol < shift) shift = ccol;
}
changed = TRUE;
break;
case _Enter:
if (nl == na)
{
na *= 2;
lines = realloc (lines, sizeof(char *) * na);
}
for (i=nl-1; i>cline; i--)
lines[i+1] = lines[i];
if (ccol < strlen (lines[cline]))
{
lines[cline+1] = strdup (lines[cline]+ccol);
lines[cline][ccol] = '\0';
}
else
{
lines[cline+1] = strdup ("");
}
ccol = 0;
shift = 0;
cline++;
if (cline-fline == video_vsize()-1) fline++;
nl++;
changed = TRUE;
break;
case _Delete:
if (ccol >= strlen (lines[cline]))
{
// glue previous line to this one
if (cline == nl-1) break;
p = malloc (ccol+strlen(lines[cline+1])+1);
strcpy (p, lines[cline]);
memset (p+strlen(lines[cline]), ' ', ccol-strlen(lines[cline]));
strcpy (p+ccol, lines[cline+1]);
free (lines[cline]);
free (lines[cline+1]);
lines[cline] = p;
for (i=cline+1; i<nl-1; i++)
lines[i] = lines[i+1];
nl--;
}
else
{
// ccol != 0: delete char at ccol-1, move cursor left
str_delete (lines[cline], lines[cline]+ccol);
}
changed = TRUE;
break;
case _F2:
rc = editor_save_file (filename);
if (rc == 0) changed = FALSE;
break;
case _Esc:
case _F10:
stop = TRUE; break;
// character keys
default:
if (k >= ' ' && k <= 255)
{
str_insert_at (cline, k, ccol);
ccol++;
changed = TRUE;
}
}
}
else if (IS_MOUSE(k))
{
}
else if (IS_SYSTEM(k))
{
switch (SYS_TYPE(k))
{
case SYSTEM_QUIT:
stop = TRUE; break;
}
}
}
if (nl != 0 && lines != NULL)
for (i=0; i<nl; i++)
free (lines[i]);
if (na != 0 && lines != NULL) free (lines);
na = 0;
lines = NULL;
}
long CHSDownloadData::GetChangedBeginDate( CodeInfo *pCode,long lBeginDate,int nSpillDays,int nPeriod )
{
if (nSpillDays <= 0)
{
return lBeginDate;
}
short nOneDayNums = 240;
short nGZIndex = MakeGZIndex(pCode->m_cCodeType);
short nMainType = MakeMarket(pCode->m_cCodeType);
if (nGZIndex)
nOneDayNums = 270;
else
nOneDayNums = 240;
int nCount = 0,nGapDays =0, nYushu =0;
CTimeSpan oneDay(1,0,0,0);
CTime tmbg = GetTimeFromIntTime(lBeginDate,nPeriod);
long lBeginMinite = lBeginDate%10000;
switch(nPeriod)
{
case PERIOD_TYPE_DAY:
while(nCount < nSpillDays)
{
tmbg += oneDay;
int nWeekEnd = tmbg.GetDayOfWeek();
if (nWeekEnd != 1 && nWeekEnd != 7)
{
nCount++;
}
}
return GetIntTimeFromTime(tmbg,nPeriod);
case PERIOD_TYPE_MINUTE1:
case PERIOD_TYPE_MINUTE5:
{
int nIndex = 1,nQiHuoMorningBegin = 900,nQZQihuoMorningBegin = 915,nStockMorningBegin = 930;
if (nPeriod == PERIOD_TYPE_MINUTE5)
{
nIndex = 5;
nQiHuoMorningBegin = 905;
nQZQihuoMorningBegin = 920;
nStockMorningBegin = 935;
}
nGapDays = nSpillDays/(nOneDayNums/nIndex);
nYushu = nSpillDays%(nOneDayNums/nIndex);
while(nCount < nGapDays)
{
tmbg += oneDay;
int nWeekEnd = tmbg.GetDayOfWeek();
if (nWeekEnd != 1 && nWeekEnd != 7)
{
nCount++;
}
}
CTime tmMoriningEnd;
CTime tmNewTime;
long lTmp = 0;
CTimeSpan tmTempSpan;
CTimeSpan min1(0,(nYushu*nIndex)/60,(nYushu*nIndex)%60,0);
CTime tmTemp = tmbg;
tmTemp += min1;
long lNewMini = GetIntTimeFromTime(tmTemp,nPeriod);
tmNewTime = tmTemp;
if (lBeginMinite < 1130)
{
long ltailMini = lNewMini%10000;
if (ltailMini <1130 )
{
return lNewMini;
}
else
{
if (nMainType == STOCK_MARKET)
{
lTmp = (lNewMini/10000) * 10000 + 1300;
}
else
{
if (!nGZIndex)
lTmp = (lNewMini/10000) * 10000 + 1330;
else
lTmp = (lNewMini/10000) * 10000 + 1300;
}
tmNewTime = GetTimeFromIntTime(lTmp,nPeriod);
tmMoriningEnd = GetTimeFromIntTime((lNewMini/10000) * 10000 + 1130,nPeriod);
tmTempSpan = tmTemp - tmMoriningEnd;
tmNewTime += tmTempSpan;
lNewMini = GetIntTimeFromTime(tmNewTime,nPeriod);
goto minite1_5;
}
}
else
{
goto minite1_5;
}
minite1_5:
if (nGZIndex)
{
if (lNewMini%10000 <= 1515)
{
return lNewMini;
}
else
{
lTmp = (lNewMini/10000) * 10000 + 1515;
tmTemp = GetTimeFromIntTime(lTmp,nPeriod);
tmTempSpan = tmNewTime - tmTemp;
lNewMini = (lNewMini/10000) * 10000 + nQZQihuoMorningBegin;
tmTemp = GetTimeFromIntTime(lNewMini,nPeriod);
tmTemp += oneDay;
tmTemp += tmTempSpan;
lNewMini = GetIntTimeFromTime(tmTemp,nPeriod);
if (lNewMini%10000 <= 1130)
{
return lNewMini;
}
tmMoriningEnd = GetTimeFromIntTime((lNewMini/10000) * 10000 + 1130,nPeriod);
tmTempSpan = tmTemp - tmMoriningEnd;
lTmp = (lNewMini/10000) * 10000 + 1300;
tmTemp = GetTimeFromIntTime(lTmp,nPeriod);
tmTemp += tmTempSpan;
return GetIntTimeFromTime(tmTemp,nPeriod);
}
}
else
{
if (lNewMini%10000 <= 1500)
{
return lNewMini;
}
else
{
lTmp = (lNewMini/10000) * 10000 + 1500;
tmTemp = GetTimeFromIntTime(lTmp,nPeriod);
tmTempSpan = tmNewTime - tmTemp;
if (nMainType == STOCK_MARKET)
lNewMini = (lNewMini/10000) * 10000 + nStockMorningBegin;
else
lNewMini = (lNewMini/10000) * 10000 + nQiHuoMorningBegin;
tmTemp = GetTimeFromIntTime(lNewMini,nPeriod);
tmTemp += oneDay;
tmTemp += tmTempSpan;
lNewMini = GetIntTimeFromTime(tmTemp,nPeriod);
if (lNewMini%10000 <= 1130)
{
return lNewMini;
}
tmMoriningEnd = GetTimeFromIntTime((lNewMini/10000) * 10000 + 1130,nPeriod);
tmTempSpan = tmTemp - tmMoriningEnd;
if (nMainType == STOCK_MARKET)
lTmp = (lNewMini/10000) * 10000 + 1300;
else
lTmp = (lNewMini/10000) * 10000 + 1330;
tmTemp = GetTimeFromIntTime(lTmp,nPeriod);
tmTemp += tmTempSpan;
return GetIntTimeFromTime(tmTemp,nPeriod);
}
}
}
break;
default:
return lBeginDate;
}
}
