void ParticleGeneration(struct i2dGrid grid, struct i2dGrid pgrid, struct Population *pp)
{
// A system of particles is generated according to the value distribution of
// grid.Values
int vmax, vmin, v;
int Xdots, Ydots;
int ix, iy, np, n;
double p;
Xdots = grid.EX; Ydots = grid.EY;
vmax = MaxIntVal(Xdots*Ydots,grid.Values);
vmin = MinIntVal(Xdots*Ydots,grid.Values);
// Just count number of particles to be generated
vmin = (double)(1*vmax + 29*vmin) / 30.0;
np = 0;
for ( ix = 0; ix < Xdots; ix++ ) {
for ( iy = 0; iy < Ydots; iy++ ) {
v = grid.Values[index2D(ix,iy,Xdots)];
if ( v <= vmax && v >= vmin ) np++;
}
}
// allocate memory space for particles
pp->np = np;
pp->weight = malloc(np*sizeof((double)1.0));
pp->x = malloc(np*sizeof((double)1.0));
pp->y = malloc(np*sizeof((double)1.0));
pp->vx = malloc(np*sizeof((double)1.0));
pp->vy = malloc(np*sizeof((double)1.0));
// Population initialization
n = 0;
for ( ix = 0; ix < grid.EX; ix++ ) {
for ( iy = 0; iy < grid.EY; iy++ ) {
v = grid.Values[index2D(ix,iy,Xdots)];
if ( v <= vmax && v >= vmin ) {
pp->weight[n] = v*10.0;
p = (pgrid.Xe-pgrid.Xs) * ix / (grid.EX * 2.0);
pp->x[n] = pgrid.Xs + ((pgrid.Xe-pgrid.Xs)/4.0) + p;
p = (pgrid.Ye-pgrid.Ys) * iy / (grid.EY * 2.0);
pp->y[n] = pgrid.Ys + ((pgrid.Ye-pgrid.Ys)/4.0) + p;
pp->vx[n] = pp->vy[n] = 0.0; // at start particles are still
n++; if ( n >= np ) break;
}
}
if ( n >= np ) break;
}
print_Population(*pp);
} // end ParticleGeneration
void
ComputeAccumulatedCost(double *mean_cost, int query_size, int data_size, int *step_list, int step_list_size, double *accumulated_cost)
{
int step_max_i = -1;
int step_max_j = -1;
for(int k=0; k < step_list_size; k++)
{
step_max_i = std::max(step_max_i, step_list[k*2]);
step_max_j = std::max(step_max_j, step_list[k*2+1]);
}
// zero out the accumulated_cost matrix
for(int i=0; i < query_size; i++)
for(int j=0; j < data_size; j++)
accumulated_cost[index2D(i, j, query_size, data_size)] = 0.0;
// compute the accumulated cost for the first element (0,0) of all classifiers
accumulated_cost[index2D(0, 0, query_size, data_size)] = mean_cost[index2D(0, 0, query_size, data_size)];
// compute the accumulated cost along the first (or last) column of all classifiers (note the sum of mean cost across rows)
for(int i=1; i < query_size; i++)
accumulated_cost[index2D(i, 0, query_size, data_size)] = accumulated_cost[index2D(i-1, 0, query_size, data_size)] + mean_cost[index2D(i, 0, query_size, data_size)];
// compute the accumulated cost along the first (or last) row of all classifiers
for(int j=1; j < data_size; j++)
accumulated_cost[index2D(0, j, query_size, data_size)] = mean_cost[index2D(0, j, query_size, data_size)];
// compute the accumulated cost using dynamic programming
for(int i = step_max_i; i < query_size; i++)
{
for(int j = step_max_j; j < data_size; j++)
{
double cost_list[step_list_size];
for(int k = 0; k < step_list_size; k++)
cost_list[k] = DBL_MAX;
for(int k = 0; k < step_list_size; k++)
{
int step_i = i-step_list[2*k];
int step_j = j-step_list[2*k+1];
if ( (step_i >= 0) and (step_j >= 0) )
cost_list[k] = accumulated_cost[index2D(step_i, step_j, query_size, data_size)];
}
accumulated_cost[index2D(i, j, query_size, data_size)] = minOfN(cost_list, step_list_size) + mean_cost[index2D(i, j, query_size, data_size)];
}
}
}
void ComptPopulation(struct Population *p, double *forces)
{
/*
* compute effects of forces on particles in a interval time
*
*/
int i;
double x0, x1, y0, y1;
for ( i = 0; i < p->np; i++ ) {
x0 = p->x[i]; y0 = p->y[i];
p->x[i] = p->x[i] + (p->vx[i]*TimeBit) +
(0.5*forces[index2D(0,i,2)]*TimeBit*TimeBit/p->weight[i]);
p->vx[i] = p->vx[i] + forces[index2D(0,i,2)]*TimeBit/p->weight[i];
p->y[i] = p->y[i] + (p->vy[i]*TimeBit) +
(0.5*forces[index2D(1,i,2)]*TimeBit*TimeBit/p->weight[i]);
p->vy[i] = p->vy[i] + forces[index2D(1,i,2)]*TimeBit/p->weight[i];
}
}
void mexFunction(int nlhs, mxArray *plhs[], /* Output variables */
int nrhs, const mxArray *prhs[] /* Input variables */){
//OUTPUT/INPUT PARAMETERS
#define HIST_OUT plhs[0]
#define IMG_IN prhs[0]
#define ROW_IN prhs[1]
#define COL_IN prhs[2]
#define BIN_IN prhs[3]
//POINTER VARIABLES
double *imgBins, *intHist;
int r, c, b, Row, Col, Bin, intHistDims[3];
//INPUT: Pointers
imgBins = mxGetPr(IMG_IN);
Row = (int)mxGetScalar(ROW_IN);
Col = (int)mxGetScalar(COL_IN);
Bin = (int)mxGetScalar(BIN_IN);
intHistDims[0] = Row;
intHistDims[1] = Col;
intHistDims[2] = Bin;
//OUTPUT: Pointers
HIST_OUT = mxCreateDoubleMatrix(Row*Col*Bin, 1, mxREAL);
intHist = mxGetPr(HIST_OUT);
mxSetDimensions(HIST_OUT, intHistDims, 3);
//memset(intHist, 0, sizeof(double)*Row*Col*Bin);
/* IMAGE INTEGRAL HISTOGRAM */
for(r=0; r<Row; r++){
for(c=0; c<Col; c++){
//INITIALIZE
for(b=0; b<Bin; b++) intHist[index3D(r,c,b,Row,Col,Bin)] = 0;
//CHECK IF IMG_IN_BINs == BIN_IN
b = imgBins[index2D(r,c,Row,Col)];
if (b > Bin) mexErrMsgTxt("IMG_IN Beans exceed BIN_IN");
intHist[index3D(r,c,b-1,Row,Col,Bin)] = 1;
for(b=0; b<Bin; b++){
if (r > 0) intHist[index3D(r,c,b,Row,Col,Bin)] += intHist[index3D(r-1,c ,b,Row,Col,Bin)];
if (c > 0) intHist[index3D(r,c,b,Row,Col,Bin)] += intHist[index3D(r ,c-1,b,Row,Col,Bin)];
if (r > 0 && c > 0) intHist[index3D(r,c,b,Row,Col,Bin)] -= intHist[index3D(r-1,c-1,b,Row,Col,Bin)];
}
}
}
}
void GeneratingField(struct i2dGrid *grid, int MaxIt)
{
/*
! Compute "generating" points
! Output:
! *grid.Values
*/
int ix, iy, iz;
double ca, cb, za, zb;
double rad, zan, zbn;
double Xinc, Yinc, Sr, Si, Ir, Ii;
int izmn, izmx;
int Xdots, Ydots;
fprintf(stdout,"Computing generating field ...\n");
Xdots = grid->EX; Ydots = grid->EY;
Sr = grid->Xe - grid->Xs;
Si = grid->Ye - grid->Ys;
Ir = grid->Xs;
Ii = grid->Ys;
Xinc = Sr / (double)Xdots;
Yinc = Si / (double)Ydots;
izmn=9999; izmx=-9;
for ( iy = 0; iy < Ydots; iy++ ) {
for ( ix = 0; ix < Xdots; ix++ ) {
ca = Xinc * ix + Ir;
cb = Yinc * iy + Ii;
rad = sqrt( ca * ca * ( (double)1.0 + (cb/ca)*(cb/ca) ) );
zan = 0.0;
zbn = 0.0;
for ( iz = 1; iz <= MaxIt; iz++ ) {
if ( rad > (double)2.0 ) break;
za = zan;
zb = zbn;
zan = ca + (za-zb)*(za+zb);
zbn = 2.0 * ( za*zb + cb/2.0 );
rad = sqrt( zan * zan * ( (double)1.0 + (zbn/zan)*(zbn/zan) ) );
}
if (izmn > iz) izmn=iz;
if (izmx < iz) izmx=iz;
if ( iz >= MaxIt ) iz = 0;
grid->Values[index2D(ix,iy,Xdots)] = iz;
}
}
return;
} // end GeneratingField
void
ComputeMeanCostForNeurons(int *neuron_cost, int query_size, int data_size, int number_of_neurons, double *mean_cost)
{
double sum;
for(int i=0; i < query_size; i++)
{
for(int j=0; j < data_size; j++)
{
sum = 0.0;
#pragma omp parallel for reduction(+:sum)
for (int neuron = 0; neuron < number_of_neurons; neuron++)
sum += (double)neuron_cost[index3D(neuron, i, j, query_size, data_size)];
mean_cost[index2D(i, j, query_size, data_size)] = sum / (double)number_of_neurons;
}
}
}
int
FindOptimalWarpingPath(double *cost_matrix, int *query_path, int *data_path, int max_path_size, int query_size, int data_size, int i, int j, int *step_list, int step_list_size)
{
int path_size = 1;
int step_max_i = -1;
int step_max_j = -1;
for(int k=0; k < step_list_size; k++)
{
step_max_i = std::max(step_max_i, step_list[k*2]);
step_max_j = std::max(step_max_j, step_list[k*2+1]);
}
query_path[0] = i;
data_path[0] = j;
while ((i-step_max_i > 0) || (j-step_max_j > 0))
{
double cost_list[step_list_size];
for(int k = 0; k < step_list_size; k++)
cost_list[k] = DBL_MAX;
for(int k = 0; k < step_list_size; k++)
{
int step_i = i-step_list[2*k];
int step_j = j-step_list[2*k+1];
if ( (step_i >= 0) and (step_j >= 0) )
cost_list[k] = cost_matrix[index2D(step_i, step_j, query_size, data_size)];
}
int k = argminOfN(cost_list, step_list_size);
i = i - step_list[2*k];
j = j - step_list[2*k+1];
if ( (i >= 0) && (j >= 0) && (path_size < max_path_size) )
{
query_path[path_size] = i;
data_path[path_size] = j;
path_size++;
}
}
copy_reverse(query_path, path_size);
copy_reverse(data_path, path_size);
return path_size;
}
int
FindSubsequenceWarpingPath(double *cost, int *query_path, int *data_path, int max_path_size, int query_size, int data_size, int *step_list, int step_list_size)
{
int a_star, b_star, path_size, full_path_size;
b_star = FindUpperBound(&(cost[index2D(query_size-1, 0, query_size, data_size)]), data_size);
full_path_size = FindOptimalWarpingPath(cost, query_path, data_path, max_path_size, query_size, data_size, query_size-1, b_star, step_list, step_list_size);
a_star = FindLowerBound(query_path, full_path_size);
path_size = 0;
for(int k=0; k < full_path_size; k++)
{
if ( (data_path[k] >= a_star) and (data_path[k] <= b_star) )
{
query_path[path_size] = query_path[k];
data_path[path_size] = data_path[k];
path_size++;
}
}
return path_size;
}
void ParticleScreen(struct i2dGrid* pgrid, struct Population pp, int step)
{
// Distribute a particle population in a grid for visualization purposes
int ix, iy, Xdots, Ydots;
int np, n, wp;
double rmin, rmax;
int static vmin, vmax;
double Dx, Dy, wint, wv;
char name[40];
Xdots = pgrid->EX; Ydots = pgrid->EY;
for ( ix = 0; ix < Xdots; ix++ ) {
for ( iy = 0; iy < Ydots; iy++ ) {
pgrid->Values[index2D(ix,iy,Xdots)] = 0;
}
}
rmin = MinDoubleVal(pp.np,pp.weight);
rmax = MaxDoubleVal(pp.np,pp.weight);
wint = rmax - rmin;
Dx = pgrid->Xe - pgrid->Xs;
Dy = pgrid->Ye - pgrid->Ys;
for ( n = 0; n < pp.np; n++ ) {
// keep a tiny border free anyway
ix = Xdots * pp.x[n] / Dx; if ( ix >= Xdots-1 || ix <= 0 ) continue;
iy = Ydots * pp.y[n] / Dy; if ( iy >= Ydots-1 || iy <= 0 ) continue;
wv = pp.weight[n] - rmin; wp = 10.0*wv/wint;
pgrid->Values[index2D(ix,iy,Xdots)] = wp;
pgrid->Values[index2D(ix-1,iy,Xdots)] = wp;
pgrid->Values[index2D(ix+1,iy,Xdots)] = wp;
pgrid->Values[index2D(ix,iy-1,Xdots)] = wp;
pgrid->Values[index2D(ix,iy+1,Xdots)] = wp;
}
sprintf(name,"stage%3.3d\0",step);
if ( step <= 0 ) { vmin = vmax = 0; }
IntVal2ppm(pgrid->EX, pgrid->EY, pgrid->Values, &vmin, &vmax, name);
} // end ParticleScreen
void SystemEvolution(struct i2dGrid *pgrid, struct Population *pp, int mxiter)
{
double *forces;
double vmin, vmax;
struct particle p1, p2;
double f[2], ftem0=0.0, ftem1=0.0;
int i, j, t;
// temporary array of forces
forces = malloc(2 * pp->np * sizeof((double)1.0));
if ( forces == NULL ) {
fprintf(stderr,"Error mem alloc of forces!\n");
exit(1);
}
// compute forces acting on each particle step by step
for ( t=0; t < mxiter; t++ ) {
fprintf(stdout,"Step %d of %d\n",t,mxiter);
for ( i=0; i < 2*pp->np; i++ ) forces[i] = 0.0;
time_t t_comuteForce_0, t_comuteForce_1;
// **** modifications
time(&t_comuteForce_0);
for ( i=0; i < pp->np; i++ )
{
newparticle(&p1,pp->weight[i],pp->x[i],pp->y[i],pp->vx[i],pp->vy[i]);
#pragma omp parallel for \
private(j, p2) firstprivate(f)\
reduction(+:ftem0,ftem1)
for ( j=0; j < pp->np; j++)
{
if ( j != i )
{
newparticle(&p2,pp->weight[j],pp->x[j],pp->y[j],pp->vx[j],pp->vy[j]);
ForceCompt(f,p1,p2);
ftem0 += f[0];
ftem1 += f[1];
// forces[index2D(0,i,2)] += f[0];
// forces[index2D(1,i,2)] += f[1];
}
}
forces[index2D(0,i,2)]= ftem0;
forces[index2D(1,i,2)]= ftem1;
}
time(&t_comuteForce_1);
fprintf(stdout,"time spent on ForceCompt(): %lf\n seconds",difftime(t_comuteForce_1,t_comuteForce_0));
// **** modifications, end
ParticleScreen(pgrid,*pp, t);
DumpPopulation(*pp, t);
ParticleStats(*pp,t);
time_t t_ComptPopulation_0, t_ComptPopulation_1;
time(&t_ComptPopulation_0);
ComptPopulation(pp,forces);
time(&t_ComptPopulation_1);
fprintf(stdout,"time spent on ComptPopulation(): %lf\n seconds",difftime(t_ComptPopulation_1,t_ComptPopulation_0));
}
free(forces);
} // end SystemEvolution
