inline void unpackAndAppendImpl(T &recv, std::tuple<A ...> &&tuple, std::index_sequence<I...>) {
Func()(recv, std::get<I>(std::move(tuple))...);
}
function_property_map(Func f = Func()) : f(f) {}
int main()
{
srand((unsigned)time(NULL));
int i, j, k, l, varw, varc1, varc2, vfun=4, vtest, vgen, temp; // iteration vars
float w, c1, c2, edge, Vmax, goal, gb, res = 0, avggennew=0; // gb is the global gbest
float vel[coornum], pbest[coornum], gbest[coornum], results[4*testnum]; // Each bird's got their own gbest
float absRadius; // Absolute perceptive radius
float relRadius; // A iteration var for radius
int radRec; // A var to count the index of the radius
int adjmat[N][N]; // Adjacent Matrix
char buffer[19]; // A buffer to write the file, 15 is the estimated char numbers
char storage[19*relRange];
/* Storage Section */
//The strategy is: we store the 'sum' into 'aves'.
//When the time comes they got loaded into the file, we'll have them become real 'average'
float AveOptGen[relRange]; // FuncNumber*RadiusNumber: Every 19[radius] with a func
float AveOptRate[relRange]; // FuncNumber*RadiusNumber: Every 19[radius] with a func
float AveDeg[relRange][gennum/aveDegInterval+1]; // [FuncNumber*RadiusNumber][Every 10 gen]
//So the truth is, we're getting the average(a matrix) of average(a test)
float AveOptFit[relRange][gennum/aveDegInterval+1]; // The average of the gbest fitness in the end of each test (last generation)
/* End of Storage Section */
for(i=0;i<relRange;i++){
AveOptGen[i]=0;
AveOptRate[i]=0;
for(j=0;j<gennum/aveDegInterval;j++){
AveDeg[i][j]=0;
AveOptFit[i][j]=0;
}
}
for(i=0;i<19*relRange;i++){
storage[i]=' ';
}
radRec=0; // Set the radius index counting number
for(relRadius=0.24;relRadius<1.01;relRadius+=0.02){ // Loop layer 1 (relRadius)
w = 0.6;
for(varw = 0; varw < 1; varw++)
{
c1 = 1.7;
for(varc1 = 0; varc1 < 1; varc1++)
{
c2 = 1.7;
for(varc2 = 0; varc2 < 1 ; varc2++)
{
edge = 600;
Vmax = edge;
goal = 0.1;
int ngoal = 0, avggen = 0; // Goal achieving flag & Average generations
for(i = 0; i < testnum; i++)
{
results[4*i] = gennum;
results[4*i+1] = 0;
results[4*i+2] = gennum;
results[4*i+3] = 0;
}
for(vtest = 0; vtest < testnum; vtest++) // Run the experiment
{
double neoDiag=0;
double dist=0;
int sum = 1;
absRadius = relRadius * sqrt(dim * pow(2 * edge , 2));
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
gbest[i] = INT_MAX;
}
//Initialization:
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
gbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
}
else
{ // i=dim
Func(j);
// Initializing pbest
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
gbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
/*
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
{
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
}
for(k = 0; k < N; k++)
if( gbest[(dim+1)*j+i] < gbest[(dim+1)*k+i])
{
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*k+l] = gbest[(dim+1)*j+l];
}
*/
} // End of the condition i = dim
} // for birds
} // for dims
//neoDiag=0;
// Producing the initiating Adjacent Matrix
for(j=0;j<N;j++)
for(k=0;k<N;k++) // Avoid Relapse
{
dist=getDistance(j,k);
if( dist <= absRadius && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else{
adjmat[j][k]=0;
}
/* if(dist>neoDiag){
printf("%d,%d,%f\n",j,k,dist);
neoDiag=dist;
}
*/
}
// End of producing the initiating Adjacent Matrix
for( j=0; j<N ; j++ )
for( k=0; k<N ; k++ )
if( adjmat[j][k] != 0) // k Can be perceived by j
temp+=1;
temp/=N;
AveDeg[radRec][0]+=temp; // Got it
// Updating each bird's gbest:
for(j=0;j<N;j++){
for(k=0;k<N;k++)
if( adjmat[j][k] != 0 ){// k Can be perceived by j
// Updating the gbest of j
//printf("%f\t",getDistance(j,k));
if( coor[(dim+1)*k+dim] < gbest[(dim+1)*j+dim] ){
for(l=0;l<=dim;l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*k+l];
}
}
//printf("gbest of %d:%f\nfitness of %d:%f\n",j,gbest[(dim+1)*j+dim],j,coor[(dim+1)*j+dim]);
}
gb = gbest[dim]; // Updating the global gbest
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
AveOptFit[radRec][0]+=gb;
// End of Updating each bird's gbest in initialization
for(vgen = 0; vgen < gennum; vgen++) // Evolution
{
float aveDegree=0; // Average Degree
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
float r1 = (double)rand() / RAND_MAX * 1;
float r2 = (double)rand() / RAND_MAX * 1;
vel[(dim+1)*j+i] = w * vel[(dim+1)*j+i] + c1 * r1 * (pbest[(dim+1)*j+i] - coor[(dim+1)*j+i])\
+ c2 * r2 * (gbest[(dim+1)*j+i] - coor[(dim+1)*j+i]);
coor[(dim+1)*j+i] += vel[(dim+1)*j+i];
}
else // i = dim
{
Func(j);
// When i = dim, updating pbest:
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
// Comparing itself with gbest:
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
} // End of else
} // for birds
} // for dims
if( (vgen+1) % (100*aveDegInterval) == 0 && vgen!=0)
{
//printf("%d,%f\n",vgen,neoDiag);
absRadius=relRadius*neoDiag;
}
neoDiag=0;
// Producing the initiating Adjacent Matrix
for( j=0; j<N ; j++ )
for( k=0; k<N; k++) // Avoid Relapse
{
dist=getDistance(j,k);
if( dist <= absRadius && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else{
adjmat[j][k]=0;
}
if( (vgen+1) % (100*aveDegInterval) == 999 )
if(dist>neoDiag){
neoDiag=dist;
//printf("%d,%d,dist:%f\t",j,k,dist);
}
}
//if(neoDiag!=0)
//printf("%d,%f\n",vgen,neoDiag);
// End of producing the initiating Adjacent Matrix
//Caculating Average Degree of the generation
if( (vgen+1) % aveDegInterval == 0 ){
for( j=0; j<N ;j++ )
for( k=0; k<N ;k++ )
if( adjmat[j][k] != 0) // k Can be perceived by j
aveDegree+=1;
aveDegree/=N; // Got it
AveDeg[radRec][(vgen+1) / aveDegInterval] += aveDegree; // Storing Average Degree of this particular generation
}
// Updating each bird's gbest:
for( j=0; j<N ;j++ ){
for( k=0; k<N ;k++ )
if( adjmat[j][k] != 0 ) // k Can be perceived by j
// Updating the gbest of j
if( coor[(dim+1)*k+dim] < gbest[(dim+1)*j+dim] )
for(l=0;l<=dim;l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*k+l];
//printf("gbest of %d:%f\nfitness of %d:%f\n",j,gbest[(dim+1)*j+dim],j,coor[(dim+1)*j+dim]);
}
// End of Updating each bird's gbest
gb = gbest[dim]; // Updating the global gbest
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
if( (vgen+1) % aveDegInterval == 0 ){
AveOptFit[radRec][(vgen+1) / aveDegInterval]+=gb;
}
if(gb < goal && sum != 0)
{
results[4*vtest] = (double)vgen+1;
results[4*vtest+1] = gb;
sum = 0;
printf("\ngb:%f,%d\t",gb,vgen);
//ngoal++;
//break;
}
if(vgen == gennum - 1)
{
results[4*vtest+2] = gennum;
results[4*vtest+3] = gb;
printf("lastgb:%f\n",gb);
}
} // for vgens
printf("\nTest%d for Function%d of relRadius%f is done. The next one's coming at ya.\n\n",vtest,vfun,relRadius);
} // for vtest
for(i = 0; i < testnum; i++)
{
if(results[4*i] != gennum)
{
ngoal++;
avggen += results[4*i];
res += results[4*i+1];
}
}
printf("%d,%d", avggen, ngoal);
if(ngoal == 0)
avggennew = (double)gennum;
else
avggennew = (double)avggen / ngoal;
printf("AVGEN:%f\t",avggennew);
AveOptGen[radRec]=avggennew;
printf("AVRATE:%f",(double)ngoal / testnum * 100);
AveOptRate[radRec]=(double)ngoal / testnum * 100;
printf("Function%d is tested under this radius.\n", vfun);
c2 += 0.1;
}
c1 += 0.1;
}
w += 0.1;
}
//} // End of Loop layer 2 (population)
radRec++;
printf("\n\nRadius %d is tested\n\n",radRec);
} // End of Loop layer 1 (relRadius)
printf("\n\n Done! You got it, dude!");
for(i=0;i<relRange;i++)
for(j=0;j<=(gennum/aveDegInterval);j++){
AveDeg[i][j]=(double)AveDeg[i][j]/testnum;
AveOptFit[i][j]=(double)AveOptFit[i][j]/testnum;
}
// Get da data in da file!
sprintf(storage,"Gen,");
for(i=0;i<relRange;i++){
sprintf(buffer,"AvDeg%d,",i);
strcat(storage,buffer);
}
pso = fopen("vicpsoFunc4-adjmat.txt", "w");
fprintf(pso, "RelRadius,AveOptGen,AveOptRate,AveDeg\n");
for(i=0;i<relRange;i++){
fprintf(pso, "%f,%f,%f\n",0.24+i*0.02,AveOptGen[i],AveOptRate[i]);
}
fclose(pso);
pso = fopen("vicpsoFunc4-adjmat-AveDeg.txt", "w");
fprintf(pso, "%s\n",storage );
for(j=0;j<=(gennum/aveDegInterval);j++){
int inIte;
fprintf(pso,"%d,",j*10);
for(inIte=0;inIte<relRange;inIte++){
fprintf(pso, "%f,",AveDeg[inIte][j]);
}
fprintf(pso, "\n");
}
fclose(pso);
pso = fopen("vicpsoFunc4-OptFit.txt", "w");
fprintf(pso, "%s\n",storage );
for(j=0;j<=(gennum/aveDegInterval);j++){
int inIte;
fprintf(pso,"%d,",j*10);
for(inIte=0;inIte<relRange;inIte++){
fprintf(pso, "%f,",AveOptFit[inIte][j]);
}
fprintf(pso, "\n");
}
fclose(pso);
return 0;
} // End of main
Val FuncTerm::val(Grounder *grounder) const
{
ValVec vals;
foreach(const Term &term, args_) vals.push_back(term.val(grounder));
return Val::create(Val::FUNC, grounder->index(Func(grounder, name_, vals)));
}
void Apply(Bitmap& bmp) const override{
Func(bmp);
}
GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, T b)
{
return tvec4<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
}
GLM_FUNC_QUALIFIER static tvec4<R, P> call(R (*Func) (T x), tvec4<T, P> const & v)
{
return tvec4<R, P>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
}
int main () {
char a;
cin>>a;
cout<<Func(a);
return 0;
}
int main(int argc, char **argv) {
// Google logging needed for parts of caffe that were extracted
// Network structure
// data - conv - reLU - pool - fc - softmax
std::vector<Layer*> network;
// Description of the neural network
int N = 100; // number of samples/batch_size
int d_w = 32; // data width
int d_h = 32; // data height
int ch = 3; // number of channels
Image<float> data(32, 32, 3, 100);
DataLayer * d_layer = new DataLayer(d_h, d_w, ch, N, data);
network.push_back(d_layer);
printf("data out size %d x %d x %d x %d\n", d_layer->out_dim_size(0),
d_layer->out_dim_size(1),
d_layer->out_dim_size(2),
d_layer->out_dim_size(3));
int n_f = 32; // number of filters
int f_w = 7; // filter width
int f_h = 7; // filter height
int pad = (f_w-1)/2; // padding required to handle boundaries
int stride = 1; // stride at which the filter evaluated
Convolutional * conv = new Convolutional(n_f, f_w, f_h, pad,
stride, d_layer);
network.push_back(conv);
printf("conv out size %d x %d x %d x %d\n", conv->out_dim_size(0),
conv->out_dim_size(1),
conv->out_dim_size(2),
conv->out_dim_size(3));
ReLU * relu = new ReLU(conv);
network.push_back(relu);
int p_w = 2; // pooling width
int p_h = 2; // pooling height
int p_stride = 2; // pooling stride
MaxPooling * pool = new MaxPooling(p_w, p_h, p_stride, relu);
network.push_back(pool);
printf("pool out size %d x %d x %d x %d\n", pool->out_dim_size(0),
pool->out_dim_size(1),
pool->out_dim_size(2),
pool->out_dim_size(3));
Flatten * flatten = new Flatten(pool);
network.push_back(flatten);
printf("flatten out size %d x %d\n", flatten->out_dim_size(0),
flatten->out_dim_size(1));
int C = 10; // number of classes
Affine * fc = new Affine(C, flatten);
network.push_back(fc);
printf("fc out size %d x %d\n", fc->out_dim_size(0),
fc->out_dim_size(1));
SoftMax * softm = new SoftMax(fc);
network.push_back(softm);
printf("softm out size %d x %d\n", softm->out_dim_size(0),
softm->out_dim_size(1));
Image<float> scores(C, N);
Image<int> labels(N);
softm->back_propagate(Func(labels));
// Schedule
conv->forward.compute_root();
pool->forward.compute_root();
fc->forward.compute_root();
softm->forward.compute_root();
conv->f_param_grads[0].compute_root();
conv->f_param_grads[1].compute_root();
conv->f_in_grad.compute_root();
fc->f_param_grads[0].compute_root();
fc->f_param_grads[1].compute_root();
fc->f_in_grad.compute_root();
pool->f_in_grad.compute_root();
conv->f_param_grads[0].print_loop_nest();
// Build
std::vector<Func> outs;
outs.push_back(softm->forward);
outs.push_back(conv->f_param_grads[0]);
Pipeline p(outs);
timeval t1, t2;
gettimeofday(&t1, NULL);
p.realize({scores, conv->param_grads[0]});
gettimeofday(&t2, NULL);
float time = (t2.tv_sec - t1.tv_sec) +
(t2.tv_usec - t1.tv_usec) / 1000000.0f;
printf("First JIT time: %f\n", time);
gettimeofday(&t1, NULL);
p.realize({scores, conv->param_grads[0]});
gettimeofday(&t2, NULL);
time = (t2.tv_sec - t1.tv_sec) +
(t2.tv_usec - t1.tv_usec) / 1000000.0f;
printf("Second JIT time: %f\n", time);
for (Layer* l: network)
delete l;
return 0;
}
unsigned PtrFunc(int (*Func)(int), int X) {
return Func(X);
}
/**
* This bracketing algorithm was taken from
* http://cxc.harvard.edu/sherpa/methods/fminpowell.py.txt
* and converted to C++.
*/
void Photometry::minbracket(double &xa, double &xb, double &xc, double &fa, double &fb,
double &fc, double Func(double par, void *params), void *params) {
double eps = 1.0e-21;
double Gold = 1.618034;
double GrowLimit = 110;
int maxiter = 1000;
fa = Func(xa, params);
fb = Func(xb, params);
if (fa < fb) {
double tmp = xa;
xa = xb;
xb = tmp;
tmp = fa;
fa = fb;
fb = tmp;
}
xc = xb + Gold * (xb - xa);
fc = Func(xc, params);
int iter = 0;
while (fc < fb) {
double tmp1 = (xb - xa) * (fb - fc);
double tmp2 = (xb - xc) * (fb - fa);
double val = tmp2 - tmp1;
double denom;
if (fabs(val) < eps) {
denom = 2.0 * eps;
} else {
denom = 2.0 * val;
}
double w = xb - ((xb -xc) * tmp2 - (xb - xa) * tmp1) / denom;
double wlim = xb + GrowLimit * (xc - xb);
if (iter > maxiter) {
IString msg = "Maximum iterations exceeded in minimum bracketing ";
msg += "algorithm (minbracket) - root cannot be bracketed";
throw IException(IException::User, msg, _FILEINFO_);
}
iter = iter + 1;
double fw;
if (((w-xc)*(xb-w)) > 0.0) {
fw = Func(w, params);
if (fw < fc) {
xa = xb;
xb = w;
fa = fb;
fb = fw;
return;
} else if (fw > fb) {
xc = w;
fc = fw;
return;
}
w = xc + Gold * (xc - xb);
fw = Func(w, params);
} else if (((w-wlim)*(wlim-xc)) >= 0.0) {
w = wlim;
fw = Func(w, params);
} else if (((w-wlim)*(xc-w)) > 0.0) {
fw = Func(w, params);
if (fw < fc) {
xb = xc;
xc = w;
w = xc + Gold * (xc - xb);
fb = fc;
fc = fw;
fw = Func(w, params);
}
} else {
w = xc + Gold * (xc - xb);
fw = Func(w, params);
}
xa = xb;
xb = xc;
xc = w;
fa = fb;
fb = fc;
fc = fw;
}
return;
}
/**
* This is the main entry point of a native application that is using
* android_native_app_glue. It runs in its own thread, with its own
* event loop for receiving input events and doing other things.
*/
void android_main(struct android_app* state) {
struct engine engine;
memset(&engine, 0, sizeof(engine));
state->userData = &engine;
state->onAppCmd = engine_handle_cmd;
state->onInputEvent = engine_handle_input;
engine.app = state;
// Prepare to monitor accelerometer
engine.sensorManager = ASensorManager_getInstance();
engine.accelerometerSensor = ASensorManager_getDefaultSensor(engine.sensorManager,
ASENSOR_TYPE_ACCELEROMETER);
engine.sensorEventQueue = ASensorManager_createEventQueue(engine.sensorManager,
state->looper, LOOPER_ID_USER, NULL, NULL);
if (state->savedState != NULL) {
// We are starting with a previous saved state; restore from it.
engine.state = *(struct saved_state*)state->savedState;
}
engine.animating = 1;
// loop waiting for stuff to do.
while (1) {
// Read all pending events.
int ident;
int events;
struct android_poll_source* source;
// If not animating, we will block forever waiting for events.
// If animating, we loop until all events are read, then continue
// to draw the next frame of animation.
while ((ident = ALooper_pollAll(engine.animating ? 0 : -1, NULL, &events,
(void**)&source)) >= 0) {
// Process this event.
if (source != NULL) {
source->process(state, source);
}
// If a sensor has data, process it now.
if (ident == LOOPER_ID_USER) {
if (engine.accelerometerSensor != NULL) {
ASensorEvent event;
while (ASensorEventQueue_getEvents(engine.sensorEventQueue,
&event, 1) > 0) {
LOGI("accelerometer: x=%f y=%f z=%f",
event.acceleration.x, event.acceleration.y,
event.acceleration.z);
}
}
}
// Check if we are exiting.
if (state->destroyRequested != 0) {
engine_term_display(&engine);
return;
}
}
if (engine.animating) {
// Done with events; draw next animation frame.
engine.state.angle += .01f;
if (engine.state.angle > 1) {
engine.state.angle = 0;
}
// Drawing is throttled to the screen update rate, so there
// is no need to do timing here.
engine_draw_frame(&engine);
Func();
}
}
}
int ApplyFuncHelper(std::array<T, N> const& arr, std::index_sequence<Inds...>)
{
return Func()(std::get<Inds, T, N>(arr)...);
}
inline void unpackAndAppend(T &recv, A &&value) {
Func()(recv, std::forward<A>(value));
}
// All-purpose routine for computing the L2-projection
// of various functions onto the gradient of the Legendre basis
// (Unstructured grid version)
//
void L2ProjectGrad_Unst(
const dTensor2* vel_vec,
const int istart,
const int iend,
const int QuadOrder,
const int BasisOrder_qin,
const int BasisOrder_auxin,
const int BasisOrder_fout,
const mesh& Mesh,
const dTensor3* qin,
const dTensor3* auxin,
dTensor3* fout,
void (*Func)(const dTensor2* vel_vec,
const dTensor2&,const dTensor2&,
const dTensor2&,dTensor3&))
{
// starting and ending indeces
const int NumElems = Mesh.get_NumElems();
assert_ge(istart,1);
assert_le(iend,NumElems);
// qin variable
assert_eq(NumElems,qin->getsize(1));
const int meqn = qin->getsize(2);
const int kmax_qin = qin->getsize(3);
assert_eq(kmax_qin,(BasisOrder_qin*(BasisOrder_qin+1))/2);
// auxin variable
assert_eq(NumElems,auxin->getsize(1));
const int maux = auxin->getsize(2);
const int kmax_auxin = auxin->getsize(3);
assert_eq(kmax_auxin,(BasisOrder_auxin*(BasisOrder_auxin+1))/2);
// fout variables
assert_eq(NumElems,fout->getsize(1));
const int mcomps_out = fout->getsize(2);
const int kmax_fout = fout->getsize(3);
assert_eq(kmax_fout,(BasisOrder_fout*(BasisOrder_fout+1))/2);
// number of quadrature points
assert_ge(QuadOrder,1);
assert_le(QuadOrder,5);
int mpoints;
switch ( QuadOrder )
{
case 1:
mpoints = 0;
break;
case 2:
mpoints = 1;
break;
case 3:
mpoints = 6;
break;
case 4:
mpoints = 7;
break;
case 5:
mpoints = 16;
break;
}
// trivial case
if ( QuadOrder==1 )
{
for (int i=istart; i<=iend; i++)
for (int m=1; m<=mcomps_out; m++)
for (int k=1; k<=kmax_fout; k++)
{ fout->set(i,m,k, 0.0 ); }
}
else
{
const int kmax = iMax(iMax(kmax_qin,kmax_auxin),kmax_fout);
dTensor2 spts(mpoints,2);
dTensor1 wgts(mpoints);
dTensor2 xpts(mpoints,2);
dTensor2 qvals(mpoints,meqn);
dTensor2 auxvals(mpoints,maux);
dTensor3 fvals(mpoints,mcomps_out,2);
dTensor2 mu(mpoints,kmax); // monomial basis (non-orthogonal)
dTensor2 phi(mpoints,kmax); // Legendre basis (orthogonal)
dTensor2 mu_xi(mpoints,kmax_fout); // xi-derivative of monomial basis (non-orthogonal)
dTensor2 mu_eta(mpoints,kmax_fout); // eta-derivative of monomial basis (non-orthogonal)
dTensor2 phi_xi(mpoints,kmax_fout); // xi-derivative of Legendre basis (orthogonal)
dTensor2 phi_eta(mpoints,kmax_fout); // eta-derivative of Legendre basis (orthogonal)
dTensor2 phi_x(mpoints,kmax_fout); // x-derivative of Legendre basis (orthogonal)
dTensor2 phi_y(mpoints,kmax_fout); // y-derivative of Legendre basis (orthogonal)
switch ( QuadOrder )
{
case 2:
spts.set(1,1, 0.0 );
spts.set(1,2, 0.0 );
wgts.set(1, 0.5 );
break;
case 3:
spts.set(1,1, 0.112615157582632 );
spts.set(1,2, 0.112615157582632 );
spts.set(2,1, -0.225230315165263 );
spts.set(2,2, 0.112615157582632 );
spts.set(3,1, 0.112615157582632 );
spts.set(3,2, -0.225230315165263 );
spts.set(4,1, -0.241757119823562 );
spts.set(4,2, -0.241757119823562 );
spts.set(5,1, 0.483514239647126 );
spts.set(5,2, -0.241757119823562 );
spts.set(6,1, -0.241757119823562 );
spts.set(6,2, 0.483514239647126 );
wgts.set(1, 0.1116907948390055 );
wgts.set(2, 0.1116907948390055 );
wgts.set(3, 0.1116907948390055 );
wgts.set(4, 0.0549758718276610 );
wgts.set(5, 0.0549758718276610 );
wgts.set(6, 0.0549758718276610 );
break;
case 4:
spts.set(1,1, 0.000000000000000 );
spts.set(1,2, 0.000000000000000 );
spts.set(2,1, 0.136808730771782 );
spts.set(2,2, 0.136808730771782 );
spts.set(3,1, -0.273617461543563 );
spts.set(3,2, 0.136808730771782 );
spts.set(4,1, 0.136808730771782 );
spts.set(4,2, -0.273617461543563 );
spts.set(5,1, -0.232046826009877 );
spts.set(5,2, -0.232046826009877 );
spts.set(6,1, 0.464093652019754 );
spts.set(6,2, -0.232046826009877 );
spts.set(7,1, -0.232046826009877 );
spts.set(7,2, 0.464093652019754 );
wgts.set(1, 0.1125000000000000 );
wgts.set(2, 0.0661970763942530 );
wgts.set(3, 0.0661970763942530 );
wgts.set(4, 0.0661970763942530 );
wgts.set(5, 0.0629695902724135 );
wgts.set(6, 0.0629695902724135 );
wgts.set(7, 0.0629695902724135 );
break;
case 5:
spts.set(1,1, 0.000000000000000 );
spts.set(1,2, 0.000000000000000 );
spts.set(2,1, 0.125959254959390 );
spts.set(2,2, 0.125959254959390 );
spts.set(3,1, -0.251918509918779 );
spts.set(3,2, 0.125959254959390 );
spts.set(4,1, 0.125959254959390 );
spts.set(4,2, -0.251918509918779 );
spts.set(5,1, -0.162764025581573 );
spts.set(5,2, -0.162764025581573 );
spts.set(6,1, 0.325528051163147 );
spts.set(6,2, -0.162764025581573 );
spts.set(7,1, -0.162764025581573 );
spts.set(7,2, 0.325528051163147 );
spts.set(8,1, -0.282786105016302 );
spts.set(8,2, -0.282786105016302 );
spts.set(9,1, 0.565572210032605 );
spts.set(9,2, -0.282786105016302 );
spts.set(10,1, -0.282786105016302 );
spts.set(10,2, 0.565572210032605 );
spts.set(11,1, -0.324938555923375 );
spts.set(11,2, -0.070220503698695 );
spts.set(12,1, -0.324938555923375 );
spts.set(12,2, 0.395159059622071 );
spts.set(13,1, -0.070220503698695 );
spts.set(13,2, -0.324938555923375 );
spts.set(14,1, -0.070220503698695 );
spts.set(14,2, 0.395159059622071 );
spts.set(15,1, 0.395159059622071 );
spts.set(15,2, -0.324938555923375 );
spts.set(16,1, 0.395159059622071 );
spts.set(16,2, -0.070220503698695 );
wgts.set(1, 0.0721578038388935 );
wgts.set(2, 0.0475458171336425 );
wgts.set(3, 0.0475458171336425 );
wgts.set(4, 0.0475458171336425 );
wgts.set(5, 0.0516086852673590 );
wgts.set(6, 0.0516086852673590 );
wgts.set(7, 0.0516086852673590 );
wgts.set(8, 0.0162292488115990 );
wgts.set(9, 0.0162292488115990 );
wgts.set(10, 0.0162292488115990 );
wgts.set(11, 0.0136151570872175 );
wgts.set(12, 0.0136151570872175 );
wgts.set(13, 0.0136151570872175 );
wgts.set(14, 0.0136151570872175 );
wgts.set(15, 0.0136151570872175 );
wgts.set(16, 0.0136151570872175 );
break;
}
// Loop over each quadrature point and construct monomial polys
for (int m=1; m<=mpoints; m++)
{
// coordinates
const double xi = spts.get(m,1);
const double xi2 = xi*xi;
const double xi3 = xi2*xi;
const double xi4 = xi3*xi;
const double eta = spts.get(m,2);
const double eta2 = eta*eta;
const double eta3 = eta2*eta;
const double eta4 = eta3*eta;
// monomial basis functions at each gaussian quadrature point
switch( kmax )
{
case 15: // fifth order
mu.set(m, 15, eta4 );
mu.set(m, 14, xi4 );
mu.set(m, 13, xi2*eta2 );
mu.set(m, 12, eta3*xi );
mu.set(m, 11, xi3*eta );
case 10: // fourth order
mu.set(m, 10, eta3 );
mu.set(m, 9, xi3 );
mu.set(m, 8, xi*eta2 );
mu.set(m, 7, eta*xi2 );
case 6: // third order
mu.set(m, 6, eta2 );
mu.set(m, 5, xi2 );
mu.set(m, 4, xi*eta );
case 3: // second order
mu.set(m, 3, eta );
mu.set(m, 2, xi );
case 1: // first order
mu.set(m, 1, 1.0 );
break;
}
// Loop over each quadrature point and construct Legendre polys
for (int i=1; i<=kmax; i++)
{
double tmp = 0.0;
for (int j=1; j<=i; j++)
{ tmp = tmp + Mmat[i-1][j-1]*mu.get(m,j); }
phi.set(m,i, tmp );
}
// Gradient of monomial basis functions at each gaussian quadrature point
switch( kmax_fout )
{
case 15: // fifth order
mu_xi.set( m,15, 0.0 );
mu_xi.set( m,14, 4.0*xi3 );
mu_xi.set( m,13, 2.0*xi*eta2 );
mu_xi.set( m,12, eta3 );
mu_xi.set( m,11, 3.0*xi2*eta );
mu_eta.set( m,15, 4.0*eta3 );
mu_eta.set( m,14, 0.0 );
mu_eta.set( m,13, 2.0*xi2*eta );
mu_eta.set( m,12, 3.0*eta2*xi );
mu_eta.set( m,11, xi3 );
case 10: // fourth order
mu_xi.set( m,10, 0.0 );
mu_xi.set( m,9, 3.0*xi2 );
mu_xi.set( m,8, eta2 );
mu_xi.set( m,7, 2.0*eta*xi );
mu_eta.set( m,10, 3.0*eta2 );
mu_eta.set( m,9, 0.0 );
mu_eta.set( m,8, 2.0*eta*xi );
mu_eta.set( m,7, xi2 );
case 6: // third order
mu_xi.set( m,6, 0.0 );
mu_xi.set( m,5, 2.0*xi );
mu_xi.set( m,4, eta );
mu_eta.set( m,6, 2.0*eta );
mu_eta.set( m,5, 0.0 );
mu_eta.set( m,4, xi );
case 3: // second order
mu_xi.set( m,3, 0.0 );
mu_xi.set( m,2, 1.0 );
mu_eta.set( m,3, 1.0 );
mu_eta.set( m,2, 0.0 );
case 1: // first order
mu_xi.set( m,1, 0.0 );
mu_eta.set( m,1, 0.0 );
break;
}
// Loop over each quadrature point and construct Legendre polys
for (int i=1; i<=kmax_fout; i++)
{
double tmp1 = 0.0;
double tmp2 = 0.0;
for (int j=1; j<=i; j++)
{
tmp1 = tmp1 + Mmat[i-1][j-1]*mu_xi.get(m,j);
tmp2 = tmp2 + Mmat[i-1][j-1]*mu_eta.get(m,j);
}
phi_xi.set(m,i, tmp1 );
phi_eta.set(m,i, tmp2 );
}
}
// -------------------------------------------------------------
// Loop over every grid cell indexed by user supplied parameters
// described by istart...iend
// -------------------------------------------------------------
#pragma omp parallel for
for (int i=istart; i<=iend; i++)
{
// Find center of current cell
const int i1 = Mesh.get_tnode(i,1);
const int i2 = Mesh.get_tnode(i,2);
const int i3 = Mesh.get_tnode(i,3);
const double x1 = Mesh.get_node(i1,1);
const double y1 = Mesh.get_node(i1,2);
const double x2 = Mesh.get_node(i2,1);
const double y2 = Mesh.get_node(i2,2);
const double x3 = Mesh.get_node(i3,1);
const double y3 = Mesh.get_node(i3,2);
const double xc = (x1+x2+x3)/3.0;
const double yc = (y1+y2+y3)/3.0;
// Compute q, aux and fvals at each Gaussian Quadrature point
// for this current cell indexed by (i,j)
// Save results into dTensor2 qvals, auxvals and fvals.
for (int m=1; m<=mpoints; m++)
{
// convert phi_xi and phi_eta derivatives
// to phi_x and phi_y derivatives through Jacobian
for (int k=1; k<=kmax_fout; k++)
{
phi_x.set(m,k, Mesh.get_jmat(i,1,1)*phi_xi.get(m,k)
+ Mesh.get_jmat(i,1,2)*phi_eta.get(m,k) );
phi_y.set(m,k, Mesh.get_jmat(i,2,1)*phi_xi.get(m,k)
+ Mesh.get_jmat(i,2,2)*phi_eta.get(m,k) );
}
// point on the unit triangle
const double s = spts.get(m,1);
const double t = spts.get(m,2);
// point on the physical triangle
xpts.set(m,1, xc + (x2-x1)*s + (x3-x1)*t );
xpts.set(m,2, yc + (y2-y1)*s + (y3-y1)*t );
// Solution values (q) at each grid point
for (int me=1; me<=meqn; me++)
{
qvals.set(m,me, 0.0 );
for (int k=1; k<=kmax_qin; k++)
{
qvals.set(m,me, qvals.get(m,me)
+ phi.get(m,k) * qin->get(i,me,k) );
}
}
// Auxiliary values (aux) at each grid point
for (int ma=1; ma<=maux; ma++)
{
auxvals.set(m,ma, 0.0 );
for (int k=1; k<=kmax_auxin; k++)
{
auxvals.set(m,ma, auxvals.get(m,ma)
+ phi.get(m,k) * auxin->get(i,ma,k) );
}
}
}
// Call user-supplied function to set fvals
Func(vel_vec, xpts, qvals, auxvals, fvals);
// Evaluate integral on current cell (project onto Legendre basis)
// using Gaussian Quadrature for the integration
for (int m1=1; m1<=mcomps_out; m1++)
for (int m2=1; m2<=kmax_fout; m2++)
{
double tmp = 0.0;
for (int k=1; k<=mpoints; k++)
{
tmp = tmp + wgts.get(k)*
( fvals.get(k,m1,1)*phi_x.get(k,m2) +
fvals.get(k,m1,2)*phi_y.get(k,m2) );
}
fout->set(i, m1, m2, 2.0*tmp );
}
}
}
}
Result operator()(Param0 p0, Param1 p1) const {
return Func(p0, p1, 0, 0);
}
int main()
{
srand((unsigned)time(NULL));
int i, j, k, l, varw, varc1, varc2, vfun=3, vtest, vgen; // iteration vars
float w, c1, c2, edge, Vmax, goal, gb, res = 0, avggennew=0; // gb is the global gbest
float vel[coornum], pbest[coornum], gbest[coornum], results[4*testnum]; // Each bird's got their own gbest
double absRadius[N],paramK[N]; // Absolute perceptive radius and the radius parameter matrix K
double relRadius; // A iteration var for radius
int radRec; // A var to count the index of the radius
int adjmat[N][N]; // Adjacent Matrix
char buffer[19]; // A buffer to write the file, 15 is the estimated char numbers
char storage[19*relRange];
/* Storage Section */
//The strategy is: we store the 'sum' into 'aves'.
//When the time comes they got loaded into the file, we'll have them become real 'average'
float AveOptGen[relRange]; // FuncNumber*RadiusNumber: Every 19[radius] with a func
float AveOptRate[relRange]; // FuncNumber*RadiusNumber: Every 19[radius] with a func
float AveOptFit[relRange][gennum/aveDegInterval+1]; // The average of the gbest fitness of the interval generations
float AveEndFit[relRange];// The average of the gbest fitness in the end of each successful test (last generation)
/* End of Storage Section */
for(i=0; i<relRange; i++)
{
AveOptGen[i]=0;
AveOptRate[i]=0;
AveEndFit[i]=0;
for(j=0; j<gennum/aveDegInterval; j++)
{
// AveDeg[i][j]=0;
AveOptFit[i][j]=0;
}
}
for(i=0; i<19*relRange; i++)
{
storage[i]=' ';
}
radRec=0; // Set the radius index counting number
for(relRadius=0.2; relRadius<1.01; relRadius+=0.05) // Loop layer 1 (relRadius)
{
w = 0.6;
for(varw = 0; varw < 1; varw++)
{
c1 = 1.7;
for(varc1 = 0; varc1 < 1; varc1++)
{
c2 = 1.7;
for(varc2 = 0; varc2 < 1 ; varc2++)
{
edge = 5.12;
Vmax = edge;
goal = 100;
int ngoal = 0, avggen = 0; // Goal achieving flag & Average generations
for(i = 0; i < testnum; i++)
{
results[4*i] = gennum;
results[4*i+1] = 0;
results[4*i+2] = gennum;
results[4*i+3] = 0;
}
for(vtest = 0; vtest < testnum; vtest++) // Run the experiment
{
double neoDiag=0;
double dist=0;
int sum = 1;
for(i = 0; i < coornum; i++)
{
pbest[i] = INT_MAX;
gbest[i] = INT_MAX;
}
//Initialization:
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
coor[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * edge - edge;
vel[(dim+1)*j+i] = (double)rand() / RAND_MAX * 2 * Vmax - Vmax;
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
gbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
}
else
{
// i=dim
Func(j);
// Initializing pbest
pbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
gbest[(dim+1)*j+i] = coor[(dim+1)*j+i];
} // End of the condition i = dim
} // for birds
} // for dims
absRadius[0] = relRadius * sqrt(dim * pow(2 * edge , 2));
for(j=0;j<N;j++){
paramK[j]=relRadius;
absRadius[j]=absRadius[0];
}
for(j=0; j<N; j++)
for(k=0; k<N; k++) // Avoid Relapse
{
dist=getDistance(j,k);
if( dist <= absRadius[j] && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else
{
adjmat[j][k]=0;
}
}
// End of producing the initiating Adjacent Matrix
// Updating each bird's gbest:
for(j=0; j<N; j++)
{
for(k=0; k<N; k++)
if( adjmat[j][k] != 0 ) // k Can be perceived by j
{
// Updating the gbest of j
//printf("%f\t",getDistance(j,k));
if( coor[(dim+1)*k+dim] < gbest[(dim+1)*j+dim] )
{
for(l=0; l<=dim; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*k+l];
}
}
//printf("gbest of %d:%f\nfitness of %d:%f\n",j,gbest[(dim+1)*j+dim],j,coor[(dim+1)*j+dim]);
}
gb = gbest[dim]; // Updating the global gbest
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
AveOptFit[radRec][0]+=gb;
// End of Updating each bird's gbest in initialization
for(vgen = 0; vgen < gennum; vgen++) // Evolution starts
{
for(i = 0; i < dim + 1; i++)
{
for(j = 0; j < N; j++)
{
if(i < dim)
{
float r1 = (double)rand() / RAND_MAX * 1;
float r2 = (double)rand() / RAND_MAX * 1;
vel[(dim+1)*j+i] = w * vel[(dim+1)*j+i] + c1 * r1 * (pbest[(dim+1)*j+i] - coor[(dim+1)*j+i])\
+ c2 * r2 * (gbest[(dim+1)*j+i] - coor[(dim+1)*j+i]);
coor[(dim+1)*j+i] += vel[(dim+1)*j+i];
}
else // i = dim
{
Func(j);
// When i = dim, updating pbest:
if(coor[(dim+1)*j+i] < pbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
pbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
// Comparing itself with gbest:
if(coor[(dim+1)*j+i] < gbest[(dim+1)*j+i])
for(l = 0; l < dim + 1; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*j+l];
} // End of else
} // for birds
} // for dims
if( (vgen+1) % (changeInte) == 0 && vgen!=0)
{
double fit[2][N];
for(j=0;j<N;j++){
fit[0][j]=coor[(dim+1)*j+dim]; // Fitness
fit[1][j]=j; // The index of particle
}
QuickSort(fit,0,N-1); // Done sorting the fitness while keeping the index
// Changing the parameter k
// The quicksort gives a small to large sequence!
for(j=0;j<N;j++){
if(j>=35){
paramK[(int)fit[1][j]]-=kstep;
if( paramK[(int)fit[1][j]] < kLowerLim)
paramK[(int)fit[1][j]] = kLowerLim;
}
if(j<15){
paramK[(int)fit[1][j]]+=kstep;
}
absRadius[(int)fit[1][j]]=paramK[(int)fit[1][j]]*neoDiag;
//printf("%d,",(int)fit[1][j]);
}
//printf("\n");
//printf("%d,%f\n",vgen,neoDiag);
}
neoDiag=0;
// Producing the initiating Adjacent Matrix
for( j=0; j<N ; j++ )
for( k=0; k<N; k++) // Avoid Relapse
{
dist=getDistance(j,k);
if( dist <= absRadius[j] && j!=k ) // k Can be perceived by j
{
adjmat[j][k]=1;
}
else
{
adjmat[j][k]=0;
}
if( (vgen+1) % changeInte == (changeInte-1) )
if(dist>neoDiag)
{
neoDiag=dist;
//printf("%d,%d,dist:%f\t",j,k,dist);
}
}
//if(neoDiag!=0)
//printf("%d,%f\n",vgen,neoDiag);
// End of producing the initiating Adjacent Matrix
/* //Caculating Average Degree of the generation
if( (vgen+1) % aveDegInterval == 0 )
{
for( j=0; j<N ; j++ )
for( k=0; k<N ; k++ )
if( adjmat[j][k] != 0) // k Can be perceived by j
aveDegree+=1;
aveDegree/=N; // Got it
AveDeg[radRec][(vgen+1) / aveDegInterval] += aveDegree; // Storing Average Degree of this particular generation
}
*/
// Updating each bird's gbest:
for( j=0; j<N ; j++ )
{
for( k=0; k<N ; k++ )
if( adjmat[j][k] != 0 ) // k Can be perceived by j
// Updating the gbest of j
if( coor[(dim+1)*k+dim] < gbest[(dim+1)*j+dim] )
for(l=0; l<=dim; l++)
gbest[(dim+1)*j+l] = coor[(dim+1)*k+l];
//printf("gbest of %d:%f\nfitness of %d:%f\n",j,gbest[(dim+1)*j+dim],j,coor[(dim+1)*j+dim]);
}
// End of Updating each bird's gbest
gb = gbest[dim]; // Updating the global gbest
for(i = 1; i < N; i++)
if(gbest[(dim+1)*i+dim] < gb)
gb = gbest[(dim+1)*i+dim];
if( (vgen+1) % aveDegInterval == 0 )
{
AveOptFit[radRec][(vgen+1) / aveDegInterval]+=gb;
}
if(gb < goal && sum != 0)
{
results[4*vtest] = (double)vgen+1;
results[4*vtest+1] = gb;
sum = 0;
printf("\ngb:%f,%d\t",gb,vgen);
//ngoal++;
//break;
}
if(vgen == gennum - 1)
{
results[4*vtest+2] = gennum;
results[4*vtest+3] = gb;
printf("lastgb:%f\n",gb);
}
} // for vgens
printf("\nTest%d for Function%d of relRadius%f is done. The next one's coming at ya.\n\n",vtest,vfun,relRadius);
} // for vtest
for(i = 0; i < testnum; i++)
{
if(results[4*i] != gennum)
{
ngoal++;
avggen += results[4*i];
res += results[4*i+1];
AveEndFit[radRec]+=results[4*i+3];
}
}
printf("%d,%d", avggen, ngoal);
if(ngoal == 0)
{
AveEndFit[radRec]=-1;
avggennew = (double)gennum;
}
else
{
AveEndFit[radRec] /= ngoal;
avggennew = (double)avggen / ngoal;
}
printf("AVGEN:%f\t",avggennew);
AveOptGen[radRec]=avggennew;
printf("AVRATE:%f",(double)ngoal / testnum * 100);
AveOptRate[radRec]=(double)ngoal / testnum * 100;
printf("Function%d is tested under this radius.\n", vfun);
c2 += 0.1;
}
c1 += 0.1;
}
w += 0.1;
}
//} // End of Loop layer 2 (population)
radRec++;
printf("\n\nRadius %d is tested\n\n",radRec);
} // End of Loop layer 1 (relRadius)
printf("\n\n Done! You got it, dude!");
for(i=0; i<relRange; i++)
for(j=0; j<=(gennum/aveDegInterval); j++)
{
AveOptFit[i][j]=(double)AveOptFit[i][j]/(testnum);
}
// Get da data in da file!
sprintf(storage,"Gen,");
for(i=0; i<relRange; i++)
{
sprintf(buffer,"ItemRel%f,",0.2+i*0.05);
strcat(storage,buffer);
}
pso = fopen("c:/pso/dynaRadKSort1.5/100/vicpsoFunc3-main.txt", "w");
fprintf(pso, "RelRadius,AveOptGen,AveOptRate\n");
for(i=0; i<relRange; i++)
{
fprintf(pso, "%f,%f,%f\n",0.2+i*0.05,AveOptGen[i],AveOptRate[i]);
}
fclose(pso);
pso = fopen("c:/pso/dynaRadKSort1.5/100/vicpsoFunc3-OptFit.txt", "w");
fprintf(pso, "%s\n",storage );
for(j=0; j<=(gennum/aveDegInterval); j++)
{
int inIte;
fprintf(pso,"%d,",j*10);
for(inIte=0; inIte<relRange; inIte++)
{
fprintf(pso, "%f,",AveOptFit[inIte][j]);
}
fprintf(pso, "\n");
}
fclose(pso);
pso = fopen("c:/pso/dynaRadKSort1.5/100/vicpsoFunc3-EndSucFit.txt","w");
for(i=0; i<relRange;i++){
fprintf(pso,"%f,%f,\n",0.2+i*0.05,AveEndFit[i]);
}
fclose(pso);
return 0;
} // End of main
Result operator()(Param0 p0, Param1 p1, const Arg& a0) const {
const Arg* const args[] = { &a0 };
return Func(p0, p1, args, 1);
}
GLM_FUNC_QUALIFIER static tvec1<R, P> call(R (*Func) (T x), tvec1<T, P> const & v)
{
return tvec1<R, P>(Func(v.x));
}
Result operator()(Param0 p0, Param1 p1, const Arg& a0, const Arg& a1,
const Arg& a2) const {
const Arg* const args[] = { &a0, &a1, &a2 };
return Func(p0, p1, args, 3);
}
GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, tvec2<T, P> const & b)
{
return tvec2<T, P>(Func(a.x, b.x), Func(a.y, b.y));
}
Result operator()(Param0 p0, Param1 p1, const Arg& a0, const Arg& a1,
const Arg& a2, const Arg& a3, const Arg& a4, const Arg& a5) const {
const Arg* const args[] = { &a0, &a1, &a2, &a3, &a4, &a5 };
return Func(p0, p1, args, 6);
}
void GroundProgramBuilder::add()
{
switch(stack_->type)
{
case LIT:
{
stack_->lits.push_back(Lit::create(stack_->type, stack_->vals.size() - stack_->n - 1, stack_->n));
break;
}
case TERM:
{
if(stack_->n > 0)
{
ValVec vals;
std::copy(stack_->vals.end() - stack_->n, stack_->vals.end(), std::back_inserter(vals));
stack_->vals.resize(stack_->vals.size() - stack_->n);
uint32_t name = stack_->vals.back().index;
stack_->vals.back() = Val::func(storage()->index(Func(storage(), name, vals)));
}
break;
}
case AGGR_SUM:
case AGGR_COUNT:
case AGGR_AVG:
case AGGR_MIN:
case AGGR_MAX:
case AGGR_EVEN:
case AGGR_EVEN_SET:
case AGGR_ODD:
case AGGR_ODD_SET:
case AGGR_DISJUNCTION:
{
assert(stack_->type != AGGR_DISJUNCTION || stack_->n > 0);
std::copy(stack_->lits.end() - stack_->n, stack_->lits.end(), std::back_inserter(stack_->aggrLits));
stack_->lits.resize(stack_->lits.size() - stack_->n);
stack_->lits.push_back(Lit::create(stack_->type, stack_->n ? stack_->aggrLits.size() - stack_->n : stack_->vals.size() - 2, stack_->n));
break;
}
case STM_RULE:
case STM_CONSTRAINT:
{
Rule::Printer *printer = output_->printer<Rule::Printer>();
printer->begin();
if(stack_->type == STM_RULE) { printLit(printer, stack_->lits.size() - stack_->n - 1, true); }
printer->endHead();
for(uint32_t i = stack_->n; i >= 1; i--) { printLit(printer, stack_->lits.size() - i, false); }
printer->end();
pop(stack_->n + (stack_->type == STM_RULE));
break;
}
case STM_SHOW:
case STM_HIDE:
{
Display::Printer *printer = output_->printer<Display::Printer>();
printLit(printer, stack_->lits.size() - 1, stack_->type == STM_SHOW);
pop(1);
break;
}
case STM_EXTERNAL:
{
External::Printer *printer = output_->printer<External::Printer>();
printLit(printer, stack_->lits.size() - 1, true);
pop(1);
break;
}
#pragma message "reimplement this"
/*
case STM_MINIMIZE:
case STM_MAXIMIZE:
case STM_MINIMIZE_SET:
case STM_MAXIMIZE_SET:
{
Optimize::Printer *printer = output_->printer<Optimize::Printer>();
bool maximize = (stack_->type == STM_MAXIMIZE || stack_->type == STM_MAXIMIZE_SET);
bool set = (stack_->type == STM_MINIMIZE_SET || stack_->type == STM_MAXIMIZE_SET);
printer->begin(maximize, set);
for(uint32_t i = stack_->n; i >= 1; i--)
{
Lit &a = stack_->lits[stack_->lits.size() - i];
Val prio = stack_->vals[a.offset + a.n + 2];
Val weight = stack_->vals[a.offset + a.n + 1];
printer->print(predLitRep(a), weight.num, prio.num);
}
printer->end();
pop(stack_->n);
break;
}
*/
case STM_COMPUTE:
{
Compute::Printer *printer = output_->printer<Compute::Printer>();
for(uint32_t i = stack_->n; i >= 1; i--)
{
Lit &a = stack_->lits[stack_->lits.size() - i];
printer->print(predLitRep(a));
}
pop(stack_->n);
break;
}
#pragma message "reimplement me!"
//case META_SHOW:
//case META_HIDE:
// case META_EXTERNAL:
// {
// Val num = stack_->vals.back();
// stack_->vals.pop_back();
// Val id = stack_->vals.back();
// stack_->vals.pop_back();
// assert(id.type == Val::ID);
// assert(num.type == Val::NUM);
// storage()->newDomain(id.index, num.num);
// if(stack_->type == META_EXTERNAL) { output_->external(id.index, num.num); }
// //else { output_->show(id.index, num.num, stack_->type == META_SHOW); }
// break;
// }
#pragma message "reimplement me!"
//case META_GLOBALSHOW:
case META_GLOBALHIDE:
{
output_->hideAll();
break;
}
default: {
doAdd();
}
}
}
Result operator()(Param0 p0, Param1 p1, const Arg& a0, const Arg& a1,
const Arg& a2, const Arg& a3, const Arg& a4, const Arg& a5,
const Arg& a6, const Arg& a7, const Arg& a8) const {
const Arg* const args[] = { &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8 };
return Func(p0, p1, args, 9);
}
void operator() () const {
*m_pRes = Func(m_Num);
}
~AutoClose()
{
Func( Value );
}
double* include(){
matrix[0][0] = 0; matrix[0][1] = 0; matrix[0][2] = Func(ModelingTime::getTime() + ModelingTime::getStep());
matrix[1][0] = 0; matrix[1][1] = 0; matrix[1][2] = -Func(ModelingTime::getTime() + ModelingTime::getStep());
return &matrix[0][0];
}
NNT Lexer::NextWord() {
// Match [a-zA-Z_][a-zA-Z0-9_]*
// We have already matched the first character
auto starting_offset = cursor.offset;
do {
IncrementCursor();
} while (IsAlphaNumericOrUnderscore(*cursor));
char old_char = *cursor;
*cursor = '\0';
std::string token = cursor.line.ptr + starting_offset;
*cursor = old_char;
// Check if the word is a type primitive/literal and if so, build the
// appropriate Node.
for (const auto &type_lit : PrimitiveTypes) {
if (type_lit.first == token) {
RETURN_TERMINAL(Type, Type_, IR::Value::Type(type_lit.second));
}
}
if (token == "true" || token == "false") {
RETURN_TERMINAL(True, Bool, IR::Value::Bool(token == "true"));
} else if (token == "null") {
RETURN_TERMINAL(Null, NullPtr, IR::Value::None());
} else if (token == "ord") {
RETURN_TERMINAL(Ord, Func(Char, Uint), IR::Value::None());
} else if (token == "ascii") {
RETURN_TERMINAL(ASCII, Func(Uint, Char), IR::Value::None());
} else if (token == "else") {
auto term_ptr = new AST::Terminal;
Cursor loc = cursor;
loc.offset = starting_offset;
term_ptr->loc = loc;
term_ptr->terminal_type = Language::Terminal::Else;
term_ptr->type = Bool;
return NNT(term_ptr, Language::kw_else);
}
#define CASE_RETURN_NNT(str, op, len) \
if (strcmp(token_cstr, str) == 0) { RETURN_NNT(str, op, len); }
auto token_cstr = token.c_str();
CASE_RETURN_NNT("in", op_b, 2)
CASE_RETURN_NNT("print", op_l, 5)
CASE_RETURN_NNT("import", op_l, 6)
CASE_RETURN_NNT("free", op_l, 4)
CASE_RETURN_NNT("while", kw_expr_block, 5)
CASE_RETURN_NNT("for", kw_expr_block, 3)
CASE_RETURN_NNT("if", kw_if, 2)
CASE_RETURN_NNT("case", kw_block, 4)
CASE_RETURN_NNT("enum", kw_block, 4)
CASE_RETURN_NNT("struct", kw_struct, 6)
CASE_RETURN_NNT("return", op_lt, 6)
CASE_RETURN_NNT("continue", op_lt, 8)
CASE_RETURN_NNT("break", op_lt, 5)
CASE_RETURN_NNT("repeat", op_lt, 6)
CASE_RETURN_NNT("restart", op_lt, 7)
#undef CASE_RETURN_NNT
Cursor loc = cursor;
loc.offset = starting_offset;
return NNT(new AST::Identifier(loc, token), Language::expr);
}
T get() const
{
return Func(Min_, Max_, State_);
}
inline auto unpackAndApply() {
return Func()();
}
