double
dfi(int n, double x) {
if (n == 0)
return 0;
if (n == 1)
return 1;
return 2 * fi(n - 1, x) + 2 * x * dfi(n - 1, x) - dfi(n - 2, x);
}
bool KMDBCreator::checkDriverDB(const QString& dirname, const QDateTime& d)
{
// don't block GUI
kapp->processEvents();
// first check current directory
QFileInfo dfi(dirname);
if (dfi.lastModified() > d)
return false;
// then check most recent file in current directory
QDir dir(dirname);
const QFileInfoList *list = dir.entryInfoList(QDir::Files,QDir::Time);
if (list && list->count() > 0 && list->getFirst()->lastModified() > d)
return false;
// then loop into subdirs
QStringList slist = dir.entryList(QDir::Dirs,QDir::Time);
for (QStringList::ConstIterator it=slist.begin(); it!=slist.end(); ++it)
if ((*it) != "." && (*it) != ".." && !checkDriverDB(dir.absFilePath(*it),d))
return false;
// everything is OK
return true;
}
bool GalleryUtil::MoveDirectory(const QFileInfo src, QFileInfo &dst)
{
QDir srcDir(src.absoluteFilePath());
dst = MakeUniqueDirectory(dst);
if (!dst.exists())
{
srcDir.mkdir(dst.absoluteFilePath());
dst.refresh();
}
if (!dst.exists() || !dst.isDir())
return false;
bool ok = true;
QDir dstDir(dst.absoluteFilePath());
srcDir.setFilter(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
QFileInfoList list = srcDir.entryInfoList();
QFileInfoList::const_iterator it = list.begin();
for (; it != list.end(); ++it)
{
const QString fn = it->fileName();
QFileInfo dfi(dstDir, fn);
ok &= Move(*it, dfi);
}
return ok && FileDelete(src);
}
bool GalleryUtil::CopyDirectory(const QFileInfo src, QFileInfo &dst)
{
QDir srcDir(src.absoluteFilePath());
dst = MakeUniqueDirectory(dst);
if (!dst.exists())
{
srcDir.mkdir(dst.absoluteFilePath());
dst.refresh();
}
if (!dst.exists() || !dst.isDir())
return false;
bool ok = true;
QDir dstDir(dst.absoluteFilePath());
QFileInfoList list = srcDir.entryInfoList();
QFileInfoList::const_iterator it = list.begin();
for (; it != list.end(); ++it)
{
const QString fn = it->fileName();
if (fn != "." && fn != "..")
{
QFileInfo dfi(dstDir, fn);
ok &= Copy(*it, dfi);
}
}
return ok;
}
int main() {
std::cout << "start" << std::endl;
typedef DiGraphAdjMatrix<std::string, int> Graph;
Graph g;
Graph::VertexPtr s = g.AddVertex("s");
Graph::VertexPtr v1 = g.AddVertex("v1");
Graph::VertexPtr v2 = g.AddVertex("v2");
Graph::VertexPtr v3 = g.AddVertex("v3");
Graph::VertexPtr v4 = g.AddVertex("v4");
Graph::VertexPtr v5 = g.AddVertex("v5");
Graph::VertexPtr v6 = g.AddVertex("v6");
Graph::VertexPtr v7 = g.AddVertex("v7");
g.AddEdge(*s, *v1, 1);
g.AddEdge(*s, *v2, 1);
g.AddEdge(*s, *v3, 1);
g.AddEdge(*v1, *v4, 1);
g.AddEdge(*v1, *v5, 1);
g.AddEdge(*v5, *v6, 1);
g.AddEdge(*v6, *v7, 1);
DepthFirstVertexIterator<std::string, int> dfi(g, *s);
while (dfi.HasNext()) {
std::cout << "v:" << dfi.Next()->GetValue() << std::endl;
}
return 0;
}
void ComplexInliner::immInline(BooleanDAG& dag){
map<string, int> fake;
DagFunctionInliner dfi(dag, functionMap, fake);
dfi.process(dag);
somethingChanged = dfi.changed();
if(mergeFunctions){
if(oldNfun > 0){
if( (dfi.nfuns() - oldNfun) > 3 && divFactor > (FRACTION + 1)){
divFactor--;
if( (dfi.nfuns() - oldNfun) > 12 ){
divFactor-= 4;
}
if( (dfi.nfuns() - oldNfun) > 40 ){
divFactor-= 4;
}
if(divFactor<(FRACTION + 1)){
divFactor = (FRACTION + 1);
}
cout<<"reducing divFactor "<<divFactor<<endl;
}
}
unifyTime.restart();
unify();
unifyTime.stop();
expectedNFuns++;
}
//cout<<" after all"<<endl;
oldNfun = dfi.nfuns();
Dout( cout<<" AFTER PROCESS "<<endl );
Dout(cout<<" end ElimFun "<<endl);
}
double
d2fi(int n, double x) {
if (n == 0)
return 0;
if (n == 1)
return 0;
return 4 * dfi(n - 1, x) + 2 * x * d2fi(n - 1, x) - d2fi(n - 2, x);
}
BEGIN_NAMESPACE_MW_MATLAB
void getEvents(MEXInputs &inputs, MEXOutputs &outputs)
{
boost::filesystem::path filename;
std::set<unsigned int> event_codes;
MWTime lower_bound, upper_bound;
inputs >> filename >> event_codes >> lower_bound >> upper_bound;
std::vector<int> codes;
std::vector<MWTime> times;
boost::container::vector<ArrayPtr> values;
try {
dfindex dfi(filename);
DataFileIndexer::EventsIterator ei = dfi.getEventsIterator(event_codes, lower_bound, upper_bound);
while (true) {
EventWrapper event = ei.getNextEvent();
if (event.empty())
break;
codes.push_back(event.getEventCode());
times.push_back(event.getTime());
values.push_back(convertDatumToArray(scarabDatumToDatum(event.getPayload())));
}
} catch (const DataFileIndexerError &e) {
throwMATLABError("MWorks:DataFileIndexerError", e.what());
}
if (outputs.count() == 3) {
outputs << codes;
outputs << times;
outputs << values;
} else {
const char *fieldNames[] = {"event_code", "time_us", "data"};
ArrayPtr result(throw_if_null, mxCreateStructMatrix(1, int(codes.size()), 3, fieldNames));
for (std::size_t i = 0; i < codes.size(); i++) {
mxSetFieldByNumber(result.get(), i, 0, Array::createScalar(codes[i]).release());
mxSetFieldByNumber(result.get(), i, 1, Array::createScalar(times[i]).release());
mxSetFieldByNumber(result.get(), i, 2, values[i].release());
}
outputs << std::move(result);
}
}
void
make_spl(points_t * pts, spline_t * spl) {
matrix_t *eqs = NULL;
double *x = pts->x;
double *y = pts->y;
double a = x[0];
double b = x[pts->n - 1];
int i, j, k;
int nb = pts->n - 3 > 10 ? 10 : pts->n - 3;
char *nbEnv = getenv("APPROX_BASE_SIZE");
if (nbEnv != NULL && atoi(nbEnv) > 0)
nb = atoi(nbEnv);
eqs = make_matrix(nb, nb + 1);
for (j = 0; j < nb; j++) {
for (i = 0; i < nb; i++)
for (k = 0; k < pts->n; k++)
add_to_entry_matrix(eqs, j, i, fi(i, x[k]) * fi(j, x[k]));
for (k = 0; k < pts->n; k++)
add_to_entry_matrix(eqs, j, nb, y[k] * fi(j, x[k]));
}
if (piv_ge_solver(eqs)) {
spl->n = 0;
return;
}
if (alloc_spl(spl, nb) == 0) {
for (i = 0; i < spl->n; i++) {
double xx = spl->x[i] = a + i * (b - a) / (spl->n - 1);
xx += 10.0 * DBL_EPSILON; //by nie ulokować punktu w poprz. przedziale
spl->f[i] = 0;
spl->f1[i] = 0;
spl->f2[i] = 0;
spl->f3[i] = 0;
for (k = 0; k < nb; k++) {
double ck = get_entry_matrix(eqs, k, nb);
spl->f[i] += ck * fi (k, xx);
spl->f1[i] += ck * dfi (k, xx);
spl->f2[i] += ck * d2fi(k, xx);
spl->f3[i] += ck * d3fi(k, xx);
}
}
}
}
void LocalXmlBackend::deleteTodos()
{
QList<ITodo*> todos;
do {
todos = m_database->getTodos( IDatabase::QueryDisposed, 100 );
for ( ITodo *todo : todos ) {
QString fileName = m_localStorageDirectory + "/" +
todo->metaAttributes().value( TodoMetaFileName, QString() ).toString();
QFileInfo fi( fileName );
if ( fi.exists() ) {
QFile file( fileName );
file.remove();
}
QFileInfo dfi( fi.absolutePath() + fi.baseName() );
if ( dfi.exists() && dfi.isDir() ) {
QDir dir( dfi.absoluteFilePath() );
dir.removeRecursively();
}
m_database->deleteTodo( todo );
delete todo;
}
} while ( !todos.isEmpty() );
}
void
make_spl(points_t * pts, spline_t * spl)
{
matrix_t *eqs= NULL;
double *x = pts->x;
double *y = pts->y;
double a = x[0];
double b = x[pts->n - 1];
int i, j, k;
int nb = pts->n - 3 > 10 ? 10 : pts->n - 3;
char *nbEnv= getenv( "APPROX_BASE_SIZE" );
if( nbEnv != NULL && atoi( nbEnv ) > 0 )
nb = atoi( nbEnv );
eqs = make_matrix(nb, nb + 1);
#ifdef DEBUG
#define TESTBASE 500
{
FILE *tst = fopen("debug_base_plot.txt", "w");
double dx = (b - a) / (TESTBASE - 1);
for( j= 0; j < nb; j++ )
xfi( a, b, nb, j, tst );
for (i = 0; i < TESTBASE; i++) {
fprintf(tst, "%g", a + i * dx);
for (j = 0; j < nb; j++) {
fprintf(tst, " %g", fi (a, b, nb, j, a + i * dx));
fprintf(tst, " %g", dfi (a, b, nb, j, a + i * dx));
fprintf(tst, " %g", d2fi(a, b, nb, j, a + i * dx));
fprintf(tst, " %g", d3fi(a, b, nb, j, a + i * dx));
}
fprintf(tst, "\n");
}
fclose(tst);
}
#endif
for (j = 0; j < nb; j++) {
for (i = 0; i < nb; i++)
for (k = 0; k < pts->n; k++)
add_to_entry_matrix(eqs, j, i, fi(a, b, nb, i, x[k]) * fi(a, b, nb, j, x[k]));
for (k = 0; k < pts->n; k++)
add_to_entry_matrix(eqs, j, nb, y[k] * fi(a, b, nb, j, x[k]));
}
#ifdef DEBUG
write_matrix(eqs, stdout);
#endif
if (piv_ge_solver(eqs)) {
spl->n = 0;
return;
}
#ifdef DEBUG
write_matrix(eqs, stdout);
#endif
if (alloc_spl(spl, nb) == 0) {
for (i = 0; i < spl->n; i++) {
double xx = spl->x[i] = a + i*(b-a)/(spl->n-1);
xx+= 10.0*DBL_EPSILON; // zabezpieczenie przed ulokowaniem punktu w poprzednim przedziale
spl->f[i] = 0;
spl->f1[i] = 0;
spl->f2[i] = 0;
spl->f3[i] = 0;
for (k = 0; k < nb; k++) {
double ck = get_entry_matrix(eqs, k, nb);
spl->f[i] += ck * fi (a, b, nb, k, xx);
spl->f1[i] += ck * dfi (a, b, nb, k, xx);
spl->f2[i] += ck * d2fi(a, b, nb, k, xx);
spl->f3[i] += ck * d3fi(a, b, nb, k, xx);
}
}
}
#ifdef DEBUG
{
FILE *tst = fopen("debug_spline_plot.txt", "w");
double dx = (b - a) / (TESTBASE - 1);
for (i = 0; i < TESTBASE; i++) {
double yi= 0;
double dyi= 0;
double d2yi= 0;
double d3yi= 0;
double xi= a + i * dx;
for( k= 0; k < nb; k++ ) {
yi += get_entry_matrix(eqs, k, nb) * fi(a, b, nb, k, xi);
dyi += get_entry_matrix(eqs, k, nb) * dfi(a, b, nb, k, xi);
d2yi += get_entry_matrix(eqs, k, nb) * d2fi(a, b, nb, k, xi);
d3yi += get_entry_matrix(eqs, k, nb) * d3fi(a, b, nb, k, xi);
}
fprintf(tst, "%g %g %g %g %g\n", xi, yi, dyi, d2yi, d3yi );
}
fclose(tst);
}
#endif
}
// void test() {
//
// aligned_buffer<short> a(16);
// aligned_buffer<short> b(16);
// aligned_buffer<short> c(16);
//
// std::fill( a.begin(), a.end(), 1 );
// std::fill( b.begin(), b.end(), 2 );
// a.m_ptr[0] = 2;
//
// typedef vector_unit<short,16> vu;
//
// vu::vec_t av = vu::load(a.m_ptr);
// vu::vec_t bv = vu::load(b.m_ptr);
//
// vu::store( vu::cmp_lt(av,bv), c.m_ptr );
//
// for( int i = 0; i < c.size(); i++ ) {
//
// std::cout << i << ": " << c.m_ptr[i] << "\n";
// }
//
// }
int main( int argc, char *argv[] ) {
// test();
// return 0;
seqs sq;
seqs sd;
// typedef mapped_file file_input;
typedef std::ifstream file_input;
if( argc != 6 ) {
throw std::runtime_error( "missing parameters. expect: <open> <ext> <query.fa> <db.fa> <matrix>" );
}
const int gap_open = atoi( argv[1] );
const int gap_extend = atoi( argv[2] );
//std::cout << "gap: " <<
std::ifstream ism( argv[5] );
scoring_matrix sm( ism );
file_input qfi( argv[3] );
inc_fasta<file_input, scoring_matrix> qfasta( qfi, sm );
file_input dfi( argv[4] );
inc_fasta<file_input, scoring_matrix> dfasta( dfi, sm );
// for( int i = 0 ; i < sd.names.size(); i++ ) {
// int sc = align<int>( sd.data[i], sq.data[0], sm );
// std::cout << sc << "\t" << sd.names[i] << "\n";
// }
#if 0
const int W = 8;
typedef short score_t;
typedef short sscore_t;
#else
const int W = 16;
typedef unsigned char score_t;
typedef char sscore_t;
#endif
persistent_state<score_t> ps;
// size_t db_size = (sd.names.size() / W ) * W;
#ifndef LOCAL_ALIGN
#define PAD_FRONT
#endif
typedef uint8_t seq_char_t;
std::string dname[W];
std::vector<seq_char_t> ddata[W];
// size_t dpad[W];
aligned_buffer<seq_char_t> ddata_int;
// std::vector<score_t> dmask[W];
std::string qname;
std::vector<seq_char_t> qdata;
bool have_input = true;
size_t n_qseq = 0;
size_t n_qchar = 0;
size_t n_dseq = 0;
size_t n_dchar = 0;
bool first_block = true;
while( have_input ) {
size_t maxlen = 0;
int lj = -1;
// determine db sequences for the current block
for( int j = 0; j < W; j++ ) {
dname[j].resize(0);
ddata[j].resize(0);
have_input = dfasta.next_seq( dname[j], ddata[j] );
// if there aren't enough db sequences left to fill the block, pad with last db sequence
if( !have_input ) {
// break immediately if there are no db sequences left (means #db-seqs % W == 0, or otherwise have_input would have been == false from last iteration)
if( j == 0 ) {
break;
} else {
dname[j] = dname[lj];
ddata[j] = ddata[lj];
}
} else {
n_dseq++;
n_dchar += ddata[j].size();
lj = j; // store largest valid 'j'
// for( int i = 0; i < ddata[j].length(); i++ ) {
//
// ddata[j][i] = sm.state_backmap(ddata[j][i]);
// }
}
// dmask[j].clear();
// dmask[j].resize(ddata[j].length(), 0xffff );
maxlen = std::max( maxlen, ddata[j].size() );
}
// jf == -1 at this point means that the block is empty (#db-seqs % W == 0)
if( lj == -1 ) {
break;
}
// WARNING: front-padding is currently defunct
#ifdef PAD_FRONT
for( int j = 0; j < W; j++ ) {
dpad[j] = maxlen - ddata[j].size();
}
#endif
// lj == -1 means that there are no remaining sequences
// std::cout << "sdis: " << sdi.size() << "\n";
aligned_buffer<sscore_t> qprofile( maxlen * W * sm.num_states());
aligned_buffer<sscore_t>::iterator qpi = qprofile.begin();
#if 0
for( int j = 0; j < sm.num_states(); j++ ) {
const int jstate = sm.get_state(j);
// const scoring_matrix::score_t *slice = sm.get_slice(jstate);
const scoring_matrix::score_t *cslice = sm.get_cslice(j);
for( int k = 0; k < maxlen; k++ ) {
for( int l = 0; l < W; l++ ) {
std::vector<seq_char_t> &sdi = ddata[l];
#ifdef PAD_FRONT
const size_t frontpad = dpad[l];//maxlen - sdi.size();
//if( k < sdi.size() ) {
if( k >= frontpad ) {
//*qpi = sm.get_score( sdi[k], jstate);
*qpi = cslice[sdi[k - frontpad]];
#else
if( k < sdi.size() ) {
// *qpi = slice[sdi[k]];
*qpi = cslice[sdi[k]];
#endif
} else {
*qpi = 0;
}
// std::cout << "prof: " << (qpi - qprofile.begin() ) << " " << *qpi << " " << int(j) << " " << char(sm.get_state(j)) << " " << sdi[k] << "\n";
qpi++;
}
}
}
#else
// setup the qprofile (= lookup table for match penalties along the db-sequences in the current block)
// this is the faster (at least on core i5) two-step version, using interleaved db-sequences
// setup buffer for interleaved db sequences
if( ddata_int.size() < maxlen * W ) {
ddata_int.resize(maxlen * W);
}
// copy individual db sequences into interleaved buffer (padding the shorter sequnences
aligned_buffer<seq_char_t>::iterator dint_iter = ddata_int.begin();
const int zero_state = sm.get_zero_state();
for( size_t i = 0; i < maxlen; i++ ) {
for( int j = 0; j < W; j++ ) {
std::vector<seq_char_t> &sdi = ddata[j];
if( i < sdi.size() ) {
*dint_iter = sdi[i];
} else {
*dint_iter = zero_state;
}
++dint_iter;
}
}
for( size_t j = 0; j < sm.num_states(); j++ ) {
dint_iter = ddata_int.begin();
const char *cslice = sm.get_cslice(j);
for( size_t k = 0; k < maxlen; k++ ) {
for( int l = 0; l < W; l++ ) {
// if( *dint_iter == zero_state ) {
// std::cout << int(cslice[*dint_iter]) << "\n";
//
// }
*qpi = cslice[*dint_iter];
++dint_iter;
++qpi;
}
}
}
#endif
// std::cout << "sdis2: " << sdi.size() << std::endl;
// aligned_buffer<short> dv(sdi.size() * W);
// short *dv_iter = dv.begin();
//
// for( int j = 0; j < sdi.size(); j++ ) {
//
// for( int k = 0; k < W; k++ ) {
// *dv_iter = sdi[j];
// dv_iter++;
// }
//
// }
// aligned_buffer<score_t> len(W);
// for( int j = 0; j < W; j++ ) {
// len.m_ptr[j] = sd.data[i + j].size();
// }
std::vector<int> out(W);
qfasta.reset();
while( qfasta.next_seq( qname, qdata )) {
if( first_block ) {
n_qseq++;
n_qchar+=qdata.size();
}
align_vec<score_t,sscore_t,W>( ps, maxlen, qdata, sm, qprofile, gap_open, gap_extend, out );
for( int j = 0; j <= lj; j++ ) {
// std::cout << out[j] << "\t" << dname[j] << " " << qname << " " << ddata[j].size() << "\n";
std::cout << out[j] << "\t" << dname[j] << "\n";
}
qname.resize(0);
qdata.resize(0);
}
first_block = false;
}
std::cerr << n_qseq << "[" << n_qchar << "] x " << n_dseq << "[" << n_dchar << "]\n";
}
