/*************************************************************************
1-dimensional Fast Hartley Transform.
Algorithm has O(N*logN) complexity for any N (composite or prime).
INPUT PARAMETERS
A - array[0..N-1] - real function to be transformed
N - problem size
OUTPUT PARAMETERS
A - FHT of a input array, array[0..N-1],
A_out[k] = sum(A_in[j]*(cos(2*pi*j*k/N)+sin(2*pi*j*k/N)), j=0..N-1)
-- ALGLIB --
Copyright 04.06.2009 by Bochkanov Sergey
*************************************************************************/
void fhtr1d(ap::real_1d_array& a, int n)
{
ftplan plan;
int i;
ap::complex_1d_array fa;
ap::ap_error::make_assertion(n>0, "FHTR1D: incorrect N!");
//
// Special case: N=1, FHT is just identity transform.
// After this block we assume that N is strictly greater than 1.
//
if( n==1 )
{
return;
}
//
// Reduce FHt to real FFT
//
fftr1d(a, n, fa);
for(i = 0; i <= n-1; i++)
{
a(i) = fa(i).x-fa(i).y;
}
}
int main()
{
int tt;scanf("%d",&tt);
while (tt>0)
{
tt--;
int n,m;
scanf("%d%d",&n,&m);
for (int i=0;i<n;i++) father[i]=i;
for (int i=0;i<m;i++)
{
int x,y;
scanf("%d%d",&x,&y);
int fx=fa(x),fy=fa(y);
if (fx!=fy)
{
father[fx]=fy;
}
}
int q;scanf("%d",&q);
while (q>0)
{
int x,y;scanf("%d%d",&x,&y);
int fx=fa(x),fy=fa(y);
if (fx!=fy) {printf("NO\n");}
else {printf("YO\n");}
q--;
}
}
return 0;
}
Bed2Fa::Bed2Fa(bool useName, const string &dbFile, const string &bedFile,
const string &fastaOutFile, bool useFasta, bool useStrand) {
_useName = useName;
_dbFile = dbFile;
_bedFile = bedFile;
_fastaOutFile = fastaOutFile;
_useFasta = useFasta;
_useStrand = useStrand;
_bed = new BedFile(_bedFile);
// Figure out what the output file should be.
if (fastaOutFile == "stdout") {
_faOut = &cout;
}
else {
// Make sure we can open the file.
ofstream fa(fastaOutFile.c_str(), ios::out);
if ( !fa ) {
cerr << "Error: The requested fasta output file (" << fastaOutFile << ") could not be opened. Exiting!" << endl;
exit (1);
}
else {
fa.close();
_faOut = new ofstream(fastaOutFile.c_str(), ios::out);
}
}
// Extract the requested intervals from the FASTA input file.
ExtractDNA();
}
void multiply_vec(const std::vector<int> &aarr, const std::vector<int> &barr,
std::vector<int> &res) {
std::vector<base> fa(aarr.begin(), aarr.end()), fb(barr.begin(), barr.end());
size_t cnt = 1;
while (cnt < std::max(aarr.size(), barr.size())) {
cnt <<= 1;
}
cnt <<= 1;
fa.resize(cnt);
fb.resize(cnt);
fft(fa, false);
fft(fb, false);
for (size_t i = 0; i < cnt; ++i) {
fa[i] *= fb[i];
}
fft(fa, true);
res.resize(cnt);
for (size_t i = 0; i < cnt; ++i) {
res[i] = int (fa[i].re + 0.5);
}
// delete [] fa;
// delete [] fb;
}
bool CDataBase::CreateNewFile(TDBFileType File)
{
CEncryptionManager enc;
CDirectAccess fa(m_FileName[File]);
fa.Size(sizeof(TGenericFileHeader));
CBlockManager bm(fa, enc);
bm.ScanFile(sizeof(TGenericFileHeader), 0, sizeof(TGenericFileHeader));
CBlockManager::WriteTransaction trans(bm);
uint32_t block;
TGenericFileHeader * buf = bm.CreateBlock<TGenericFileHeader>(block, cHeaderBlockSignature);
uint32_t size = 0;
uint32_t sig = -1;
TGenericFileHeader * h = bm.ReadBlock<TGenericFileHeader>(0, size, sig);
memset(h, 0, sizeof(TGenericFileHeader));
memcpy(&h->Gen.Signature, &cFileSignature[File], sizeof(h->Gen.Signature));
h->Gen.Version = cDBVersion;
h->Gen.FileSize = fa.Size();
memcpy(buf, h, sizeof(TGenericFileHeader));
bm.UpdateBlock(block, 0);
bm.UpdateBlock(0, -1);
return true;
}
FA::StatePair REParser::quantified(const FA::StatePair & p, const Quantifier & q) {
FA dfa;
{
FA fa(this->fa);
fa.removeAllMarks();
fa.setStart(p.first);
fa.addMark(p.second, 0);
dfa=fa.deterministic();
}
QList<FA::StatePair> pairs;
int i(0);
for(; i<q.min; ++i) {
pairs.append(fa.insert(dfa, false));
}
if(q.max>0) {
for(; i<q.max; ++i) {
pairs.append(reoptional_impl(fa.insert(dfa, false), -1));
}
} else {
pairs.append(reclosure_impl(fa.insert(dfa, false), -1));
}
for(i=1; i<pairs.size(); i++) {
pairs[0]=reconcat_impl(pairs[0], pairs[i], -1);
}
Q_ASSERT(pairs.size());
int rid(-1);
if(rec) {
rid=rec->uniqueId();
rec->addLine(QString("FA::StatePair p%1(reparser.quantified(p%2, REParser::Quantifier(%3)));").arg(rid).arg(p.rid).arg(q.max>=0?QString("%1,%2").arg(q.min).arg(q.max):QString().setNum(q.min)));
}
pairs[0].rid=rid;
return pairs[0];
}
vector<int64_t> multiply(const vector<int64_t>& a, const vector<int64_t>& b) {
int n1 = a.size(), n2 = b.size();
int m = 1;
while (m < n1 || m < n2) m <<= 1;
m <<= 1;
vector<Complex> fa(m, 0), fb(m, 0);
for (int i = 0; i < n1; ++i) {
fa[i] = a[i];
}
for (int i = 0; i < n2; ++i) {
fb[i] = b[i];
}
fft(fa, false);
fft(fb, false);
for (int i = 0; i < m; ++i) {
fa[i] *= fb[i];
}
fft(fa, true);
vector<int64_t> res(m);
for (int i = 0; i < m; ++i) {
res[i] = (int64_t) (fa[i].real + 0.5);
}
return res;
}
/* Main Implementation -------------------------------------------------------*/
int main( int argc, char *argv[] )
{
if (argc == 2 && strcmp(argv[1], "--help") == 0) {
std::cout << "Input Format:\n\n"
<< "Initial State: {3}\n"
<< "Final States: {12,...}\n"
<< "Total States: 15\n"
<< "State a b E\n"
<< "1 {...} {...} {...}\n"
<< "... ...\n";
exit(0);
}
int initState=0, totalStates=0;
std::vector<int> finalStates;
std::string alphabet;
scanf("Initial State: {%d}\n", &initState); // read initial state
read_final_states(&finalStates); // read final states
scanf("Total States: %d\n", &totalStates); // read total no. of states
read_alphabet(&alphabet); // read alphabet
// Create NFA in memory and read transition table from stdin
Automata fa(alphabet, initState-1, totalStates, finalStates);
read_automata(&fa);
// Convert to dfa
convert_nfa_dfa(&fa);
fa.Print();
return 0;
}
void BigIntegerStrassen::Multiply(const BigIntegerStrassen &right_number){
vcomp fa(number.begin(), number.end());
auto right_arr = right_number.ToArray();
vcomp fb(right_arr.begin(), right_arr.end());
ll n = 1;
while (n < std::max(number.size(), right_arr.size())) n <<= 1;
n <<= 1;
fa.resize(n);
fb.resize(n);
FastFourierTransform(fa, false);
FastFourierTransform(fb, false);
for (ll i = 0; i < n; i++) fa[i] *= fb[i];
FastFourierTransform(fa, true);
number.resize(n);
ll carry = 0;
for (ll i = 0; i < n; i++){
carry += ll(fa[i].real() + 0.5);
number[i] = carry % base;
carry /= base;
}
while (number.size() && number.back() == 0) number.pop_back();
}
void MovingMonsters::FillDistances()
{
_currentDistance = 0;
_somethingChanged = true;
while (_somethingChanged) //нашлись ли еще ходы
{
_somethingChanged = false; //сбрасываем флажок
//перебираем клетки
for (int row = _fieldBottom; row <= _fieldTop; row++)
{
for (int col = _fieldLeft; col <= _fieldRight; col++)
{
Game::FieldAddress fa(col, row);
if (_movesToRecievers[fa] == _currentDistance) //из этой надо двигаться дальше
{
//специально проверяем приемник с заказом
if (_currentDistance == 0) //расстояние 0 значит приемник прямо тут
{
EnergyReceiver *reciever = Gadgets::receivers.GetReceiverOnSquare(fa);
if (reciever && reciever->IsOrdered())
{ //если есть заказ то придти к приемнику один фиг нельзя
continue;
}
}
UpdateDistance(fa, fa.UP);
UpdateDistance(fa, fa.LEFT);
UpdateDistance(fa, fa.RIGHT);
UpdateDistance(fa, fa.DOWN);
}
}
}
++_currentDistance;
}
}
void FileAllocator::testAlloc(){
FileAllocator fa(9*512*2/3);
fa.setNextCluster(0, FileAllocator::EndOfClusterChain);
fa.setNextCluster(1, FileAllocator::EndOfClusterChain);
{
int32_t noCluster = fa.allocate();
assert(noCluster != -1 && noCluster > 1);
//std::cout << "allocated no cluster is: " << noCluster << std::endl;
fa.setNextCluster(noCluster, EndOfClusterChain);
assert(fa.isLastCluster(noCluster));
assert(fa.getNextCluster(noCluster) == EndOfClusterChain);
fa.free(noCluster);
}
{
int32_t noCluster = fa.allocate();
//fill the data in this cluster....
fa.setNextCluster(noCluster, FileAllocator::EndOfClusterChain);
int32_t noNextCluster = fa.allocate();
//fill the data in this cluster ....
fa.setNextCluster(noCluster, noNextCluster);
fa.setNextCluster(noNextCluster, FileAllocator::EndOfClusterChain);
assert(true == fa.isUsed(noNextCluster));
assert(true == fa.isUsed(noCluster));
fa.free(noCluster);
assert(true == fa.isFree(noCluster));
assert(true == fa.isFree(noNextCluster));
}
}
int main()
{
Loki::FixedAllocator fa(sizeof(Obj));
Loki::SmallObjAllocator sa(3 * sizeof(Obj), sizeof(Obj));
Obj * p1[4];
Obj * p2[4];
for (int k = 0; k<4; k++) {
p1[k] = reinterpret_cast<Obj*>(fa.Allocate());
p2[k] = (Obj*)sa.Allocate(sizeof(Obj));
std::cout << p1[k] << " " << p2[k] << "\n";
}
for (int k = 0; k<4; k++) {
fa.Deallocate(p1[k]);
sa.Deallocate(p2[k], sizeof(Obj));
}
typedef Loki::SmallObject< Loki::SingleThreaded,
3 * sizeof(Obj),
sizeof(Obj) > sobj;
for (int k = 0; k<4; k++) {
p1[k] = (Obj*)sobj::operator new(sizeof(Obj));
p2[k] = (Obj*)sobj::operator new(sizeof(Obj));
std::cout << p1[k] << " " << p2[k] << "\n";
}
for (int k = 0; k<4; k++) {
sobj::operator delete(p1[k], sizeof(Obj));
}
for (int k = 0; k<4; k++) {
std::cout << p2[k] << "\n";
}
for (int k = 0; k<4; k++) {
sobj::operator delete(p2[k], sizeof(Obj));
}
}
void REParser::defineAs(const QString & id) {
Q_ASSERT(id=="." || !defs.contains(id));
if(id==".") {
Q_ASSERT(!dot);
dot=true;
FA fa_dot;
const FA::State startSate(fa_dot.addState());
const FA::State finalState(fa_dot.addState());
fa_dot.setStart(startSate);
Q_ASSERT(defs.contains("."));
FA::StatePair p(fa_dot.insert(defs["."]));
fa_dot.addETransition(startSate, p.first);
fa_dot.addETransition(p.second, finalState);
fa_dot.addMark(p.second, 0);
for(int i=0; i<6; i++) {
FA fa(fa_dot);
p=fa.insert(faForCharClass((CharClass)i));
fa.addETransition(startSate, p.first);
fa.addETransition(p.second, finalState);
fa.addMark(p.second, 1);
fa=fa.deterministic();
QVector<FA::State> finals;
for(int s(0); s<fa.count(); ++s) {
const FA::State curState(s);
if(fa.marks(curState).size()==2)finals.append(curState);
}
fa.removeAllMarks();
foreach(FA::State s, finals) {
fa.addMark(s, 0);
}
fa=fa.minimal();
predefs[i]=fa;
}
void debug(void){A name,seq;C err,*sp,*spz,*spp;DC si;
sp=scad; spz=sczad; spp=scpad; si=sitop;
if(!debugb||!si) R;
if(DCPARS==si->t) si=si->lnk;
if(!si || DCDEFN!=si->t && DCSCRP!=si->t) R;
err=jerr; jerr=0;
if(!debadd(DCDEBG)){debugb=0; jsignal(EVSYSTEM); R;}
sitop->ln=err;
if(DCDEFN==si->t){
name=scnm(CSPARS);
seq=srd(name,local);
seq=append(sc(si->ln),seq);
symbis(name,seq,local);
susp();
scad=sp; sczad=spz; scpad=spp;
switch(susact){
case SUSNON: break;
case SUSRUN: break;
case SUSRET: symbis(name, mtv, local); break;
case SUSPOP: symbis(name, mtv, local); break;
case SUSRES: break;
case SUSNXT: symbis(name, behead(seq), local); break;
}} else if(DCSCRP==si->t){
susp();
scad=sp; sczad=spz; scpad=spp;
switch(susact){
case SUSNON: break;
case SUSRUN: scad=scpad; break;
case SUSRET: fa(qpopres); qpopres=0;
case SUSPOP: scad=0; break;
case SUSRES: break;
case SUSNXT: break;
}}
susact=SUSNON; debz();
}
LL fa(int nr) {
if(nr==1) return 1;
int i=0;
for(;1LL<<i<nr;++i);
--i;
return 2*fa(nr-(1<<i));
}
int main(int argc, char **argv) {
int a;
switch (a) {
case 0:
return 0;
default:
return 1;
}
for (int i = 0; i < 10; i++) {
a = i;
}
while (!a) {
a++;
}
do {
--a;
} while (a);
if (fa(a)) {
a = 1;
} else if (fb(b)) {
a = 2;
} else {
a = 3;
}
}
int main(int c, char **v)
{int rv;
double a, b;
char *ss;
unsigned char *us;
const char *cs;
rv = 0;
a = 1.0;
/* warn about statement with no effect */
b == a;
cs = "abcd";
/* warn about const qualifier */
ss = cs;
/* warn about signed/unsigned mismatch */
us = fa(ss);
/* warn about signed/unsigned mismatch */
ss = us;
return(rv);}
void f_main()
{
int n=1;
printf("在主程中，调用函数fa之前：n=%d\n",n);
fa(n);
printf("在主程中，调用函数fa之后,调用函数fb之前：n=%d\n",n);
fb(n);
printf("在主程中，调用函数fb之后：n=%d\n",n);
}
void GO(int x,int fx){
int px=b[COT2::a[x]];BIT::I(px,-1);BIT::I(b[COT2::a[x]]=D[x]=fx==-1?1:D[fx]+1,1);
for(QUE*p=Q[x];p;p=p->next)if(!p->ans){
int fu=fa(p->u);if(!D[fu])continue;
p->ans=BIT::S(D[fu])+Calc(p->u,fu,x)+Calc(p->v,fu,x);
Clean(p->u);Clean(p->v);
}for(EDGE*p=COT2::map[x];p;p=p->next)if(!d[p->y]&&p->y!=fx)CT::T[p->y]=CT::I(CT::T[x],0,n,COT2::a[p->y]),GO(p->y,x);
BIT::I(b[COT2::a[x]]=px,1);BIT::I(D[x],-1);D[x]=0;
}inline bool Run(){
void main()
{
int n=1;
printf("在主程中，调用函数fa之前：n=%d\n",n);
fa(n);
printf("在主程中，调用函数fa之后,调用函数fb之前：n=%d\n",n);
fb(&n); /* 实参为n的地址 */
printf("在主程中，调用函数fb之后：n=%d\n",n);
}
int main()
{
printf("&i1=%p\n", &i1);
printf("&i2=%p\n", &i2);
printf("&i3=%p\n", &i3);
printf("&i4=%p\n", &i4);
printf("&i5=%p\n", &i5);
fa(100);
while(1);
}
int main(){
printf("i1=%p\n",&i1);
printf("i2=%p\n",&i2);
printf("i3=%p\n",&i3);
printf("i4=%p\n",&i4);
fa(1);
printf("fa=%p\n",fa);
printf("pid=%d\n",getpid());
while(1);
}//cat /proc/pid/maps
wxArrayString FileAnalysis::ParseForIncludes()
{
if (m_Verbose)
m_Log << _T("- Searching in \"") << m_FileName << _T("\" for included headers.\n");
m_IncludedHeaders.Clear();
for (size_t LineIdx = 0; LineIdx < m_LinesOfFile.GetCount(); ++LineIdx )
{
const wxString Line = m_LinesOfFile.Item(LineIdx);
const wxRegEx RegEx(reInclude);
wxString Include;
if (RegEx.Matches(Line))
{
Include = RegEx.GetMatch(Line, 1);
}
// Include is empty if the RegEx did *not* match.
if (!Include.IsEmpty())
{
if (m_Verbose)
m_Log << _T("- Include detected via RegEx: \"") << Include << _T("\".\n");
m_IncludedHeaders.Add(Include);
// if it's a source file try to obtain the included header file
if ( !m_IsHeaderFile )
{
wxFileName FileToParseFile(m_FileName);
wxFileName IncludeFile(Include); // e.g. myheader.h
if ( FileToParseFile.GetName().IsSameAs(IncludeFile.GetName()) )
{
if (m_Verbose)
m_Log << _T("- Recursing into \"") << IncludeFile.GetFullName() << _T("\" for more included headers.\n");
// "Recursion" -> do another file analysis on the header file
FileAnalysis fa(FileToParseFile.GetPath()+
FileToParseFile.GetPathSeparator()+
IncludeFile.GetFullName());
fa.LoadFile();
wxArrayString MoreIncludedHeaders = fa.ParseForIncludes();
// Only add headers that are not included by the source file
for ( size_t i = 0; i < MoreIncludedHeaders.GetCount(); ++i )
if ( m_IncludedHeaders.Index(MoreIncludedHeaders[i]) == wxNOT_FOUND )
m_IncludedHeaders.Add(MoreIncludedHeaders[i]);
m_Log << fa.GetLog();
m_HasHeaderFile = true;
}
}
}
}
return m_IncludedHeaders;
}
int main()
{
printf("i1 addr=%p\n", &i1);
printf("i2 addr=%p\n", &i2);
printf("i3 addr=%p\n", &i3);
printf("i4 addr=%p\n", &i4);
printf("i5 addr=%p\n", &i5);
fa(100);
while(1);
return 0;
}
int main(){
printf("pid = %d\n",getpid());//取进程的ID；
printf("@全局i1 = %p\n",&i1);
printf("@全局i2 = %p\n",&i2);
printf("@BSS段i3 = %p\n",&i3);
printf("@只读常量i4 = %p\n",&i4);
printf("@代码fa = %p\n",fa);
fa(1);
sleep(20);//死循环；
return 0;
}
int main(){
printf("i1=%p\n",&i1);
printf("i2=%p\n",&i2);
printf("i3=%p\n",&i3);
printf("i4=%p\n",&i4);
printf("i5=%p\n",&i5);
printf("fa=%p\n",fa);
fa(100);
while(1);
return 0;
}
int main(int argc, char* argv[])
{
ifstream fs(argv[1]);
ifstream ft(argv[2]);
ifstream fa(argv[3]);
string line_tree,line_str,line_align;
vector<vector<string> > line_tree_vecs;
vector<vector<string> > line_str_vecs;
vector<vector<string> > line_align_vecs;
int block_size = 1000;
load_data_into_blocks(line_tree_vecs,fs,block_size);
load_data_into_blocks(line_str_vecs,ft,block_size);
load_data_into_blocks(line_align_vecs,fa,block_size);
ofstream fs2t("rules.s2t");
ofstream ft2s("rules.t2s");
if (!fs2t.is_open() || !ft2s.is_open())
return 0;
int processed_num = 0;
int block_num = line_tree_vecs.size();
for (size_t i=0;i<block_num;i++)
{
vector<vector<string> > fw_rules_vec;
vector<vector<string> > bw_rules_vec;
block_size = line_tree_vecs.at(i).size();
fw_rules_vec.resize(block_size);
bw_rules_vec.resize(block_size);
#pragma omp parallel for num_threads(16)
for (size_t j=0;j<block_size;j++)
{
RuleExtractor rule_extractor(line_tree_vecs.at(i).at(j),line_str_vecs.at(i).at(j),line_align_vecs.at(i).at(j));
if (rule_extractor.flag == false)
continue;
rule_extractor.extract_rules();
rule_extractor.dump_rules(fw_rules_vec.at(j),bw_rules_vec.at(j));
}
processed_num += block_size;
cerr<<processed_num<<endl;
for (auto &rules : fw_rules_vec)
{
for (auto &rule : rules)
{
fs2t<<rule<<endl;
}
}
for (auto &rules : bw_rules_vec)
{
for (auto &rule : rules)
{
ft2s<<rule<<endl;
}
}
}
}
char a_getchar(ac_node *p)
{
//返回节点p的字母 若为根节点则输出@
if(p->a_fa == NULL)
return('@');
ac_node *fa(p->a_fa);
for(int i = 0; i < MAX; ++ i)
if(fa->a_ch[i] == p)
return('a' + i);
return('@');
}
void RichEdit::SpellerAdd(const WString& w, int lang)
{
if(!SpellWord(w, w.GetCount(), lang)) {
Speller *f = sGetSpeller(lang);
if(f) {
FileAppend fa(sUserFile(lang));
fa.PutLine(ToUtf8(w));
f->user.Add(w);
speller_cache.Clear();
}
}
}
void MovingMonsterSources::LoadLevel(rapidxml::xml_node<> *root)
{
rapidxml::xml_node<> *elem = root->first_node("MovingMonsterSources");
if( elem ) {
elem = elem->first_node("Source");
while( elem )
{
Game::FieldAddress fa(elem);
_sources.insert( std::make_pair(fa, 0) );
elem = elem->next_sibling("Source");
}
}
}
