static int suni_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
{
switch (cmd) {
case SONET_GETSTATZ:
case SONET_GETSTAT:
return fetch_stats(dev, arg, cmd == SONET_GETSTATZ);
case SONET_SETDIAG:
return change_diag(dev,arg,1);
case SONET_CLRDIAG:
return change_diag(dev,arg,0);
case SONET_GETDIAG:
return get_diag(dev,arg);
case SONET_SETFRAMING:
if (!capable(CAP_NET_ADMIN))
return -EPERM;
return set_framing(dev, arg);
case SONET_GETFRAMING:
return get_framing(dev, arg);
case SONET_GETFRSENSE:
return -EINVAL;
case ATM_SETLOOP:
if (!capable(CAP_NET_ADMIN))
return -EPERM;
return set_loopback(dev,(int)(unsigned long)arg);
case ATM_GETLOOP:
return put_user(PRIV(dev)->loop_mode,(int __user *)arg) ?
-EFAULT : 0;
case ATM_QUERYLOOP:
return put_user(ATM_LM_LOC_PHY | ATM_LM_RMT_PHY,
(int __user *) arg) ? -EFAULT : 0;
default:
return -ENOIOCTLCMD;
}
}
static int suni_ioctl(struct atm_dev *dev,unsigned int cmd,void *arg)
{
switch (cmd) {
case SONET_GETSTATZ:
case SONET_GETSTAT:
return fetch_stats(dev,(struct sonet_stats *) arg,
cmd == SONET_GETSTATZ);
case SONET_SETDIAG:
return change_diag(dev,arg,1);
case SONET_CLRDIAG:
return change_diag(dev,arg,0);
case SONET_GETDIAG:
return get_diag(dev,arg);
case SONET_SETFRAMING:
if (arg != SONET_FRAME_SONET) return -EINVAL;
return 0;
case SONET_GETFRAMING:
return put_user(SONET_FRAME_SONET,(int *) arg) ?
-EFAULT : 0;
case SONET_GETFRSENSE:
return -EINVAL;
case ATM_SETLOOP:
return set_loopback(dev,(int) (long) arg);
case ATM_GETLOOP:
return put_user(PRIV(dev)->loop_mode,(int *) arg) ?
-EFAULT : 0;
case ATM_QUERYLOOP:
return put_user(ATM_LM_LOC_PHY | ATM_LM_RMT_PHY,
(int *) arg) ? -EFAULT : 0;
default:
return -ENOIOCTLCMD;
}
}
MDArray<double> Shrinkage::get_target_B()
{
MDArray<double> target(vec(P,P));
double avg=get_mean(get_diag(S_MLE));
for(int i=0;i<P;i++)
for(int j=0;j<P;j++)
if (i==j)
target.set(i,i,avg);
return target;
}
double Shrinkage::get_lambda_var()
{
generate_wk(data,0);
double sum_up=0,sum_d=0;
double median=get_median(get_diag(S_MLE));
for (int i=0;i<P;i++){
sum_up+=w_var(wk,i,i);
sum_d+=(S_MLE.get(i,i)-median)*(S_MLE.get(i,i)-median);
}
return round_lambda(sum_up/sum_d);
}
void I2D_PenalizationOperator::compute_dragandstuff(Real time, const Real D, const Real cor[2], string filename)
{
const Real maxu = max(fabs(Uinf[0]), fabs(Uinf[1]));
const Real U_infinity = (maxu==0.0)?1:maxu;
map<int, Diagnostic> diagnostics;
vector<BlockInfo> vInfo = grid.getBlocksInfo();
for(vector<BlockInfo>::iterator it=vInfo.begin(); it!=vInfo.end(); it++)
diagnostics[it->blockID] = Diagnostic();
ComputeDiagnostics get_diag(diagnostics, lambda, Uinf, cor);
block_processing.process(vInfo, grid.getBlockCollection(), get_diag);
Diagnostic global;
for(map< int, Diagnostic>::iterator it=diagnostics.begin(); it!=diagnostics.end(); it++)
global += it->second;
const Real cD = 2*global.force[0]/(pow(U_infinity, 2)*D);
const Real cL = 2*global.force[1]/(pow(U_infinity, 2)*D);
this->Cd = cD;
this->Cl = cL;
const Real rho = 1.0;
const Real q = 0.5*rho*U_infinity*U_infinity;
const Real Cm = -global.torque[0]/(q*D*D);
const Real T = 2*U_infinity*time/D;
const Real Area = global.area;
const Real GridPoints = global.gridpoints;
const Real Circulation = fabs(global.circulation);
const int totalNumPoints = vInfo.size()*B::sizeX*B::sizeX;
FILE * f = fopen(filename.data(), bAppendToFile ? "a" : "w");
assert(f!=NULL);
if (!bAppendToFile)
fprintf(f, "T\t\tcD\t\tcL\t\tCm\t\tcirculation\t\tArea\t\tpoints\t\tN-obstcl-1D\n");
fprintf(f, "%e\t%e\t%e\t%e\t%e\t%e\t%d\t%f\n", T, cD, cL, Cm, Circulation, Area, totalNumPoints, pow((float)GridPoints, (float)(1./2.)));
fclose(f);
printf("%e\t%e\t%e\t%e\t%e\t%e\t%d\t%f\n", T, cD, cL, Cm, Circulation, Area, totalNumPoints, pow((float)GridPoints, (float)(1./2.)));
bAppendToFile = true;
}
double Shrinkage::get_lambda_C()
{
double sum_up=0,sum_d=0,avg_diag=get_mean(get_diag(S_MLE)),avg_off_diag(get_mean(get_off_diag(S_MLE)));
generate_wk(data,0);
for(int i=0;i<P;i++)
for(int j=0;j<P;j++)
if (i!=j){
sum_up+=w_var(wk,i,j);
sum_d+=(S_MLE.get(i,j)-avg_off_diag)*(S_MLE.get(i,j)-avg_off_diag);
}
else{
sum_up+=w_var(wk,i,i);
sum_d+=(S_MLE.get(i,i)-avg_diag)*(S_MLE.get(i,i)-avg_diag);
}
return round_lambda(sum_up/sum_d);
}
static pwr_tStatus IoAgentRead(io_tCtx ctx, io_sAgent* ap)
{
io_sLocalHilscher_cifX_PnController* local
= (io_sLocalHilscher_cifX_PnController*)ap->Local;
pwr_sClass_Hilscher_cifX_PnController* op
= (pwr_sClass_Hilscher_cifX_PnController*)ap->op;
int32_t sts;
if (local->diag_cnt == 0)
get_diag(&op->Diag, local->chan);
if (local->diag_cnt > local->diag_interval)
local->diag_cnt = 0;
else
local->diag_cnt++;
// Read input area
if (local->input_area_size) {
sts = xChannelIORead(
local->chan, 0, 0, local->input_area_size, local->input_area, 10);
op->Status = sts;
if (sts == CIFX_NO_ERROR) {
if (local->dev_init)
local->dev_init = 0;
} else {
if (sts == CIFX_DEV_NO_COM_FLAG && local->dev_init
&& local->dev_init_cnt < local->dev_init_limit)
local->dev_init_cnt++;
else {
xDriverGetErrorDescription(sts, op->ErrorStr, sizeof(op->ErrorStr));
op->ErrorCount++;
}
}
if (op->ErrorCount == op->ErrorSoftLimit && !local->softlimit_logged) {
errh_Error("IO Error soft limit reached on agent '%s'", ap->Name);
local->softlimit_logged = 1;
}
if (op->ErrorCount >= op->ErrorHardLimit) {
ctx->Node->EmergBreakTrue = 1;
return IO__ERRDEVICE;
}
}
// Get Alarm or Diag
CIFX_PACKET* msg = (CIFX_PACKET*)calloc(1, sizeof(CIFX_PACKET));
sts = xChannelGetPacket(local->chan, sizeof(*msg), msg, 0);
if (sts != CIFX_NO_ERROR) {
if (!(sts == CIFX_DEV_GET_TIMEOUT || sts == CIFX_DEV_GET_NO_PACKET))
printf("Diag msg status 0x%08x\n", sts);
} else {
printf("Diag message ?\n");
switch (((TLR_PACKET_HEADER_T*)msg)->ulCmd) {
case PNIO_APCTL_CMD_APPL_ALARM_IND: {
// Response, return the package
APIOC_ALARM_RSP_T alarm_rsp = { { 0 } };
alarm_rsp.tHead.ulDest = HOST_TO_LE32(PNM_APPLICATION);
alarm_rsp.tHead.ulLen = HOST_TO_LE32(sizeof(alarm_rsp.tData));
alarm_rsp.tHead.ulCmd = HOST_TO_LE32(PNIO_APCTL_CMD_APPL_ALARM_RSP);
alarm_rsp.tHead.ulSrc = HOST_TO_LE32(PN_SRC);
alarm_rsp.tHead.ulSrcId = HOST_TO_LE32(PN_SRCID);
alarm_rsp.tData.ulHandle = ((APIOC_ALARM_IND_T*)msg)->tData.ulHandle;
alarm_rsp.tData.usAlarmSpecifier
= ((APIOC_ALARM_IND_T*)msg)->tData.usAlarmSpecifier;
sts = xChannelPutPacket(local->chan, (CIFX_PACKET*)&alarm_rsp, 10);
printf("Alarm ind\n");
// Ack the alarm
APIOC_ALARM_ACK_REQ_T alarm_ack = { { 0 } };
APIOC_ALARM_ACK_CNF_T alarm_ack_cnf = { { 0 } };
alarm_ack.tHead.ulDest = HOST_TO_LE32(PNM_APPLICATION);
alarm_ack.tHead.ulLen = HOST_TO_LE32(sizeof(alarm_ack.tData));
alarm_ack.tHead.ulCmd = HOST_TO_LE32(PNIO_APCTL_CMD_APPL_ALARM_ACK_CNF);
alarm_ack.tHead.ulSrc = HOST_TO_LE32(PN_SRC);
alarm_ack.tHead.ulSrcId = HOST_TO_LE32(PN_SRCID);
alarm_ack.tData.ulHandle = ((APIOC_ALARM_IND_T*)msg)->tData.ulHandle;
alarm_ack.tData.usAlarmSpecifier
= ((APIOC_ALARM_IND_T*)msg)->tData.usAlarmSpecifier;
alarm_ack.tData.usReserved = 0;
sts = xChannelPutPacket(local->chan, (CIFX_PACKET*)&alarm_ack, 10);
if (sts == CIFX_NO_ERROR) {
sts = xChannelGetPacket(local->chan, sizeof(alarm_ack_cnf),
(CIFX_PACKET*)&alarm_ack_cnf, 20);
if (sts == CIFX_NO_ERROR) {
printf("ALARM_ACK\n");
printf("Status 0x%08x\n", alarm_ack_cnf.tHead.ulSta);
}
}
break;
}
case PNIO_APCTL_CMD_APPL_DIAG_DATA_IND: {
// Response, return the package
APIOC_DIAG_DATA_RSP_T diag_data_rsp = { { 0 } };
diag_data_rsp.tHead.ulDest = HOST_TO_LE32(PNM_APPLICATION);
diag_data_rsp.tHead.ulLen = HOST_TO_LE32(sizeof(diag_data_rsp.tData));
diag_data_rsp.tHead.ulCmd
= HOST_TO_LE32(PNIO_APCTL_CMD_APPL_DIAG_DATA_RSP);
diag_data_rsp.tHead.ulSrc = HOST_TO_LE32(PN_SRC);
diag_data_rsp.tHead.ulSrcId = HOST_TO_LE32(PN_SRCID);
diag_data_rsp.tData.ulHandle
= ((APIOC_DIAG_DATA_IND_T*)msg)->tData.ulHandle;
sts = xChannelPutPacket(local->chan, (CIFX_PACKET*)&diag_data_rsp, 10);
printf("Diag data\n");
break;
}
default:
printf(
"Unexpected cmd received: %u\n", ((TLR_PACKET_HEADER_T*)msg)->ulCmd);
}
}
free(msg);
return IO__SUCCESS;
}
int main() {
int n,looplim = 10000;
while(cin >> n) {
vMat all_Mat;
Mat sec_Mat;
cout << "=======" << endl;
cout << n << endl;
Mat L;
double start_t = clock();
double ans = INF;
double t3 = 0,t4 = 0;
clock_t c1,c2;
//step 0
vd ans_v;
for(int i = 0 ; i < n ; i++) {
vd tmpl,x;
for(int j = 0 ; j < n ; j++) {
if(i == j) {x.push_back(1);}
else {x.push_back(0);}
}
if(get_f(x) <= ans) {
ans = get_f(x);
ans_v = x;
}
for(int j = 0 ; j < n ; j++) {
if(x[j] == 1) {
tmpl.push_back(get_f(x));
} else {
tmpl.push_back(INF);
}
}
L.push_back(tmpl);
}
int cnt = 0;
vMat used_Mat;//,all_Mat;
all_Mat.push_back(L);
sec_Mat.push_back(get_sec(L));
multimap<double,Mat> dMatmp;
set<pvdi> st;
set<pdi> stf;
vector<set<pdi> > vst(n);
set<int> used_idx;
st.insert(make_pair(get_diag(L),all_Mat.size()-1));
stf.insert(make_pair(L[0][0],all_Mat.size()-1));
priority_queue<pair<double,int> , vector<pair<double,int> > , greater<pair<double,int> > > pq;
//priority_queue<pair<double,int> > pq;
pq.push(make_pair(get_d(L),all_Mat.size()-1));
//O(min(loop,local min))
int max_set_size = 1000000;
int cut_cnt = 0;
while(cnt++ < looplim && !pq.empty()) {
if(pq.size() > 1000000) break;
if(cnt % 1000 == 0) {
cout << "cnt:" << cnt << endl;
cout << "lb:" << pq.top().first << endl;
cout << "f:" << ans << endl;
cout << "size:" << pq.size() << endl;
cout << "cut:" << cut_cnt << endl;
cout << "time:" << (clock() - start_t)/CLOCKS_PER_SEC << endl;
cout << "---" << endl;
}
//step 1
//select l in Lk with the smallest d
double d = pq.top().first;
int idx = pq.top().second;
pq.pop();
L = all_Mat[idx];
//print_Mat(L);
//print_Mat(L);
//cout << endl;
if(used_idx.find(idx) != used_idx.end()){
continue;
}
if(ans - d < eps) {
break;
}
vd xs;
for(int i = 0 ; i < L.size() ; i++) {
//caution : division by zero
xs.push_back(d/L[i][i]);
}
//step 2
double tmpf = get_f(xs);
//print_v(xs);
//cout << get_f(xs) << endl;
if(tmpf <= ans) {
ans = tmpf;
ans_v = xs;
}
vd lk;
for(int i = 0 ; i < xs.size() ; i++) {
if(xs[i] > zero_boundary) lk.push_back(tmpf/xs[i]);
else lk.push_back(INF);
}
vMat Lm;
vi idxs = get_lower_idx_s(st,lk);
//vi idxs = get_lower_idx(st,lk,vst);
//vi idxs = get_lower_idx_s(st,lk);
Mat Sec;
for(int i = 0 ; i < idxs.size() ; i++) {
if(used_idx.find(idxs[i]) == used_idx.end()){
used_idx.insert(idxs[i]);
Lm.push_back(all_Mat[idxs[i]]);
Sec.push_back(sec_Mat[idxs[i]]);
}
}
used_idx.insert(idx);
//step 4
//O(L- size * n * n^2)
vd dlk = lk;
for(int j = 0 ; j < Lm.size() ; j++) {
Mat tmpL = Lm[j];
vd tmplk = lk;
//print_Mat(tmpL);
//cout << endl;
vi idx = get_swap_idx(tmplk,Sec[j]);
/*
cout << "s:" << endl;
for(int i = 0 ; i < idx.size() ; i++) {
cout << idx[i] << " ";
}
cout << endl;
*/
for(int i = 0 ; i < idx.size() ; i++) {
L = tmpL;
lk = tmplk;
//print_Mat(L);
swap(L[idx[i]],lk);
//cout << "--" << endl;
//print_v(Sec[j]);
//cout << "v:" << is_valid_combination(L,Sec[j]) << " " << is_valid_combination(L) << endl;
//if(get_d(L) > d) {
all_Mat.push_back(L);
sec_Mat.push_back(get_sec(L));
st.insert(make_pair(get_diag(L),all_Mat.size()-1));
stf.insert(make_pair(L[0][0],all_Mat.size()-1));
pq.push(make_pair(get_d(L),all_Mat.size()-1));
//}
swap(L[idx[i]],lk);
}
}
priority_queue<pair<double,int> , vector<pair<double,int> > , greater<pair<double,int> > > tmp_pq = pq;
priority_queue<pair<double,int> , vector<pair<double,int> > , greater<pair<double,int> > > nxt_pq;
int set_size = 0;
while(!tmp_pq.empty()) {
set_size++;
int idx = tmp_pq.top().second;
if(set_size < max_set_size) nxt_pq.push(tmp_pq.top());
else {
st.erase(make_pair(get_diag(all_Mat[idx]),idx));
}
tmp_pq.pop();
}
pq = nxt_pq;
}
cout << "cnt:" << cnt << endl;
cout << "ans:" << ans << endl;
cout << "ans_v:";
print_v(ans_v);
}
return 0;
}
