double *iter2(double *y0, double x0, double h, double *y, int cnt)
{
int i;
double k1,k2,k3,k4;
double *tmp = malloc (cnt * sizeof(double));
for (i = 0; i < cnt; i++)
{
k1 = func[i](x0, y0);
k2 = func[i](x0 + h/2, hn(y0, cnt, h, k1, tmp));
k3 = func[i](x0 + h/2, hn(y0, cnt, h, k2, tmp));
k4 = func[i](x0 + h, hm(y0, cnt, h, k3, tmp));
y[i] = y0[i] + (k1 + 2 * k2 + 2 * k3 + k4) * h / 6;
}
free(tmp);
return y;
}
extern "C" void equ_makeTable(SuperEqState *state, REAL *lbc,void *_param,REAL fs)
{
paramlist *param = (paramlist *)_param;
int i,cires = state->cur_ires;
REAL *nires;
if (fs <= 0) return;
paramlist param2;
for (int ch = 0; ch < state->channels; ch++) {
process_param(lbc,param,param2,fs,ch);
for(i=0;i<state->winlen;i++)
state->irest[i] = hn(i-state->winlen/2,param2,fs)*win(i-state->winlen/2,state->winlen);
for(;i<state->tabsize;i++)
state->irest[i] = 0;
rfft(state->fft_bits,1,state->irest);
nires = cires == 1 ? state->lires2 : state->lires1;
nires += ch * state->tabsize;
for(i=0;i<state->tabsize;i++)
nires[i] = state->irest[i];
}
state->chg_ires = cires == 1 ? 2 : 1;
}
void equ_makeTable(REAL *lbc,REAL *rbc,paramlist *param,REAL fs)
{
int i,cires = cur_ires;
REAL *nires;
if (fs <= 0) return;
paramlist param2;
// L
process_param(lbc,param,param2,fs,0);
for(i=0;i<winlen;i++)
irest[i] = hn(i-winlen/2,param2,fs)*win(i-winlen/2,winlen);
for(;i<tabsize;i++)
irest[i] = 0;
rfft(tabsize,1,irest);
nires = cires == 1 ? lires2 : lires1;
for(i=0;i<tabsize;i++)
nires[i] = irest[i];
process_param(rbc,param,param2,fs,1);
// R
for(i=0;i<winlen;i++)
irest[i] = hn(i-winlen/2,param2,fs)*win(i-winlen/2,winlen);
for(;i<tabsize;i++)
irest[i] = 0;
rfft(tabsize,1,irest);
nires = cires == 1 ? rires2 : rires1;
for(i=0;i<tabsize;i++)
nires[i] = irest[i];
//
chg_ires = cires == 1 ? 2 : 1;
}
void ReadStrOut(std::string fname, Latgas_Hamiltonian& hamilton, Latgas_Hamiltonian::Config& sigma)
{
const bool verbose = false;
typedef Vec<float,3> Vec3;
Vec3 a[3]; // unit cell vector
Vec3 rL[3]; // extent
std::ifstream fin;
try
{
fin.open(fname.c_str());
}
catch(...)
{
std::cout << "ReadStrOut could not open \"" << fname << "\"" << std::endl;
return;
}
if( !fin || fin.eof() )
{
std::cout << "ReadStrOut could not open \"" << fname << "\"" << std::endl;
return;
}
// read system box information
fin >> a[0][0] >> a[0][1] >> a[0][2];
fin >> a[1][0] >> a[1][1] >> a[1][2];
fin >> a[2][0] >> a[2][1] >> a[2][2];
fin >> rL[0][0] >> rL[0][1] >> rL[0][2];
fin >> rL[1][0] >> rL[1][1] >> rL[1][2];
fin >> rL[2][0] >> rL[2][1] >> rL[2][2];
// Test matches grid in all but extent?
// assume cubic
hamilton.grid.L[0] = static_cast<int>(rL[0][0]);
hamilton.grid.L[1] = static_cast<int>(rL[1][1]);
hamilton.grid.L[2] = static_cast<int>(rL[2][2]);
int nsite = hamilton.grid.size();
if(verbose) std::cout << "ReadStrOut nsite=" << nsite << std::endl;
// Create a list of species
std::map<std::string,int> ispecies;
for(int i=0; i<hamilton.species.size(); i++)
ispecies.insert( std::make_pair(hamilton.species[i],i) );
if(verbose) std::cout << "ReadStrOut MSpecies=" << ispecies.size() << std::endl;
// Read the configuration proper
sigma.resize(nsite);
int isite = 0;
while( isite<nsite && !fin.eof() )
{
float r0, r1, r2;
std::string label;
fin >> r0 >> r1 >> r2 >> label;
int hn0 = static_cast<int>(2*r0);
int hn1 = static_cast<int>(2*r1);
int hn2 = static_cast<int>(2*r2);
Grid::NrmVec hn(hn0,hn1,hn2);
int index = hamilton.grid.index(hn);
sigma[index] = ispecies[label];
isite++;
}
// if(isite!=nsite) std::cout << "ReadStrOut only " << isite << " atoms listed out of " << nsite << std::endl;
if(verbose) std::cout << "ReadStrOut config read" << std::endl;
}
static EString randomChallenge()
{
EString hn( Configuration::hostname() );
EString random( Entropy::asString( 12 ).e64() );
if ( hn.isEmpty() || hn.find( '.' ) < 0 )
hn = "aox.invalid";
return "<" + random + "@" + hn + ">";
}
void WingedEdgeBuilder::transformNormals(const real *normals, unsigned nsize, const Matrix44r& transform, real *res)
{
const real *n = normals;
real *pn = res;
for (unsigned int i = 0; i < nsize / 3; i++) {
Vec3r hn(n[0], n[1], n[2]);
hn = GeomUtils::rotateVector(transform, hn);
for (unsigned int j = 0; j < 3; j++)
pn[j] = hn[j];
n += 3;
pn += 3;
}
}
auto moveto(const CFDAStar::NODE& node, T insert2, Y check_pass, U hn) {
CFDAStar::NODE tmp;
// 计算节点位置
tmp.x = node.x + xplus; tmp.y = node.y + yplus;
// 可以通行
if (!check_pass(tmp.x, tmp.y)) return;
// 记录父节点位置
tmp.px = -xplus; tmp.py = -yplus;
// 计算g(n)
tmp.gn = node.gn + gplus;
// f(n) = g(n) + h(n)
tmp.fn = tmp.gn + hn(tmp.x, tmp.y);
// 插入
insert2(tmp);
};
TH1F* newDumHistForLegend(const Plot_t* hist) {
// caller is responsible for deleting the hist
TH1F* h = 0;
if (hist!=0) {
TString hn(Form("%s_leg%s",hist->GetName(),
(gPad!=0) ? gPad->GetName() : ""));
h = new TH1F(hn.Data(), "", 1, 0, 1);
h->SetFillColor(hist->GetLineColor());
h->SetLineColor(kWhite);
h->SetMarkerColor(kWhite);
h->SetMarkerStyle(hist->GetMarkerStyle());
h->SetMarkerSize(1);
h->SetBit(TObject::kCanDelete);
}
return h;
}
/* "104444001" ==
* "102000301"
*
* "4441" basically means "hold for three rows then hold for another tap";
* since taps don't really have a length, it's equivalent to "4440".
* So, make sure the character after a 4 is always a 0. */
void NoteData::Convert4sToHoldNotes()
{
int rows = GetLastRow();
for( int col=0; col<m_iNumTracks; col++ ) // foreach column
{
for( int i=0; i<=rows; i++ ) // foreach TapNote element
{
if( GetTapNote(col, i).type == TapNote::hold ) // this is a HoldNote body
{
HoldNote hn( col, i, 0 );
// search for end of HoldNote
do {
SetTapNote(col, i, TAP_EMPTY);
i++;
} while( GetTapNote(col, i).type == TapNote::hold );
SetTapNote(col, i, TAP_EMPTY);
hn.iEndRow = i;
AddHoldNote( hn );
}
}
}
}
void nmf(viennacl::matrix_base<NumericT> const & V,
viennacl::matrix_base<NumericT> & W,
viennacl::matrix_base<NumericT> & H,
viennacl::linalg::nmf_config const & conf)
{
viennacl::hsa::context & ctx = const_cast<viennacl::hsa::context &>(viennacl::traits::hsa_context(V));
const std::string NMF_MUL_DIV_KERNEL = "el_wise_mul_div";
viennacl::linalg::opencl::kernels::nmf<NumericT, viennacl::hsa::context>::init(ctx);
vcl_size_t k = W.size2();
conf.iters_ = 0;
if (viennacl::linalg::norm_frobenius(W) <= 0)
W = viennacl::scalar_matrix<NumericT>(W.size1(), W.size2(), NumericT(1), ctx);
if (viennacl::linalg::norm_frobenius(H) <= 0)
H = viennacl::scalar_matrix<NumericT>(H.size1(), H.size2(), NumericT(1), ctx);
viennacl::matrix_base<NumericT> wn(V.size1(), k, W.row_major(), ctx);
viennacl::matrix_base<NumericT> wd(V.size1(), k, W.row_major(), ctx);
viennacl::matrix_base<NumericT> wtmp(V.size1(), V.size2(), W.row_major(), ctx);
viennacl::matrix_base<NumericT> hn(k, V.size2(), H.row_major(), ctx);
viennacl::matrix_base<NumericT> hd(k, V.size2(), H.row_major(), ctx);
viennacl::matrix_base<NumericT> htmp(k, k, H.row_major(), ctx);
viennacl::matrix_base<NumericT> appr(V.size1(), V.size2(), V.row_major(), ctx);
NumericT last_diff = 0;
NumericT diff_init = 0;
bool stagnation_flag = false;
for (vcl_size_t i = 0; i < conf.max_iterations(); i++)
{
conf.iters_ = i + 1;
{
hn = viennacl::linalg::prod(trans(W), V);
htmp = viennacl::linalg::prod(trans(W), W);
hd = viennacl::linalg::prod(htmp, H);
viennacl::hsa::kernel & mul_div_kernel = ctx.get_kernel(viennacl::linalg::opencl::kernels::nmf<NumericT>::program_name(), NMF_MUL_DIV_KERNEL);
viennacl::hsa::enqueue(mul_div_kernel(H, hn, hd, cl_uint(H.internal_size1() * H.internal_size2())));
}
{
wn = viennacl::linalg::prod(V, trans(H));
wtmp = viennacl::linalg::prod(W, H);
wd = viennacl::linalg::prod(wtmp, trans(H));
viennacl::hsa::kernel & mul_div_kernel = ctx.get_kernel(viennacl::linalg::opencl::kernels::nmf<NumericT>::program_name(), NMF_MUL_DIV_KERNEL);
viennacl::hsa::enqueue(mul_div_kernel(W, wn, wd, cl_uint(W.internal_size1() * W.internal_size2())));
}
if (i % conf.check_after_steps() == 0) //check for convergence
{
appr = viennacl::linalg::prod(W, H);
appr -= V;
NumericT diff_val = viennacl::linalg::norm_frobenius(appr);
if (i == 0)
diff_init = diff_val;
if (conf.print_relative_error())
std::cout << diff_val / diff_init << std::endl;
// Approximation check
if (diff_val / diff_init < conf.tolerance())
break;
// Stagnation check
if (std::fabs(diff_val - last_diff) / (diff_val * NumericT(conf.check_after_steps())) < conf.stagnation_tolerance()) //avoid situations where convergence stagnates
{
if (stagnation_flag) // iteration stagnates (two iterates with no notable progress)
break;
else
// record stagnation in this iteration
stagnation_flag = true;
} else
// good progress in this iteration, so unset stagnation flag
stagnation_flag = false;
// prepare for next iterate:
last_diff = diff_val;
}
}
}
void nmf(viennacl::matrix<ScalarType> const & v,
viennacl::matrix<ScalarType> & w,
viennacl::matrix<ScalarType> & h,
std::size_t k,
ScalarType eps = 0.000001,
std::size_t max_iter = 10000,
std::size_t check_diff_every_step = 100)
{
viennacl::linalg::kernels::nmf<ScalarType, 1>::init();
w.resize(v.size1(), k);
h.resize(k, v.size2());
std::vector<ScalarType> stl_w(w.internal_size1() * w.internal_size2());
std::vector<ScalarType> stl_h(h.internal_size1() * h.internal_size2());
for (std::size_t j = 0; j < stl_w.size(); j++)
stl_w[j] = static_cast<ScalarType>(rand()) / RAND_MAX;
for (std::size_t j = 0; j < stl_h.size(); j++)
stl_h[j] = static_cast<ScalarType>(rand()) / RAND_MAX;
viennacl::matrix<ScalarType> wn(v.size1(), k);
viennacl::matrix<ScalarType> wd(v.size1(), k);
viennacl::matrix<ScalarType> wtmp(v.size1(), v.size2());
viennacl::matrix<ScalarType> hn(k, v.size2());
viennacl::matrix<ScalarType> hd(k, v.size2());
viennacl::matrix<ScalarType> htmp(k, k);
viennacl::matrix<ScalarType> appr(v.size1(), v.size2());
viennacl::vector<ScalarType> diff(v.size1() * v.size2());
viennacl::fast_copy(&stl_w[0], &stl_w[0] + stl_w.size(), w);
viennacl::fast_copy(&stl_h[0], &stl_h[0] + stl_h.size(), h);
ScalarType last_diff = 0.0f;
for (std::size_t i = 0; i < max_iter; i++)
{
{
hn = viennacl::linalg::prod(trans(w), v);
htmp = viennacl::linalg::prod(trans(w), w);
hd = viennacl::linalg::prod(htmp, h);
viennacl::ocl::kernel & mul_div_kernel = viennacl::ocl::get_kernel(viennacl::linalg::kernels::nmf<ScalarType, 1>::program_name(),
NMF_MUL_DIV_KERNEL);
viennacl::ocl::enqueue(mul_div_kernel(h, hn, hd, cl_uint(stl_h.size())));
}
{
wn = viennacl::linalg::prod(v, trans(h));
wtmp = viennacl::linalg::prod(w, h);
wd = viennacl::linalg::prod(wtmp, trans(h));
viennacl::ocl::kernel & mul_div_kernel = viennacl::ocl::get_kernel(viennacl::linalg::kernels::nmf<ScalarType, 1>::program_name(),
NMF_MUL_DIV_KERNEL);
viennacl::ocl::enqueue(mul_div_kernel(w, wn, wd, cl_uint(stl_w.size())));
}
if (i % check_diff_every_step == 0)
{
appr = viennacl::linalg::prod(w, h);
viennacl::ocl::kernel & sub_kernel = viennacl::ocl::get_kernel(viennacl::linalg::kernels::nmf<ScalarType, 1>::program_name(),
NMF_SUB_KERNEL);
//this is a cheat. i.e save difference of two matrix into vector to get norm_2
viennacl::ocl::enqueue(sub_kernel(appr, v, diff, cl_uint(v.size1() * v.size2())));
ScalarType diff_val = viennacl::linalg::norm_2(diff);
if((diff_val < eps) || (fabs(diff_val - last_diff) < eps))
{
//std::cout << "Breaked at diff - " << diff_val << "\n";
break;
}
last_diff = diff_val;
//printf("Iteration #%lu - %.5f \n", i, diff_val);
}
}
}
void
h (void)
{
auto int hn (int); /* { dg-error "nested function 'hn' declared but never defined" } */
hn (1);
}
void MainWindow::processDatagrams()
{
const hdr_t *request;
do {
qint64 sz = _udpSocket.pendingDatagramSize();
Q_ASSERT(sz >= (qint64) sizeof(hdr_t));
QByteArray datagram(sz,0);
QByteArray rdatagram;
QHostAddress host;
quint16 port;
bool res;
Q_ASSERT(sz == _udpSocket.readDatagram(datagram.data(), datagram.size(), &host, &port));
request = (hdr_t*) datagram.constData();
Q_ASSERT(datagram.size() == request->pdusz);
// _log << "Req:" << *request << endl;
// skip respons messages
if(request->cmdid >= RDSK_Response)
{
// _log << ", skip" << endl;
continue;
}
QHostInfo hi = QHostInfo::fromName(host.toString());
QString hn(hi.hostName());
QVariant var;
CPMClient* client;
QList<QTreeWidgetItem*> clientitem = ui->treeWidget->findItems(hn,Qt::MatchFixedString);
if(clientitem.isEmpty())
{
client = new CPMClient(hn);
connect(client,SIGNAL(adddrive(CPMClient*,CPMDrive*)),this,SLOT(adddrive(CPMClient*,CPMDrive*)));
var.setValue(client);
QTreeWidgetItem *item = new QTreeWidgetItem(QStringList(hn));
item->setData(0,Qt::UserRole, var);
ui->treeWidget->addTopLevelItem(item);
}
else
{
var = clientitem.first()->data(0,Qt::UserRole);
}
client = qobject_cast<CPMClient*>(qvariant_cast<QObject*>(var));
Q_ASSERT(client);
res = client->req(*request, rdatagram);
hdr_t *response = (hdr_t*)rdatagram.data();
if(!res)
_log << "ERR:" << *response << endl;
sz = _udpSocket.writeDatagram((const char*)response, (qint64)response->pdusz, host, port);
if(_clientwidget)
_clientwidget->update();
Q_ASSERT( sz == response->pdusz);
}while(_udpSocket.hasPendingDatagrams());
