void update(int x, int y, ll v) {
int m = (s+e)/2;
if (s == e) val->update(y, v);
else {
if (x > m) {
if (r == NULL) r = new row(x, x);
else if (!r->inrange(x)) {
row* tmp = r;
pi nxt = lca(s, e, r->s, r->e, x);
r = new row(nxt.first, nxt.second);
if (tmp->e <= (r->s + r->e)/2 ) r->l = tmp;
else r->r = tmp;
r->val = tmp->val->clone();
}
r->update(x, y, v);
}
else {
if (l == NULL) l = new row(x, x);
else if (!l->inrange(x)) {
row* tmp = l;
pi nxt = lca(s, e, l->s, l->e, x);
l = new row(nxt.first, nxt.second);
if (tmp->e <= (l->s + l->e)/2 ) l->l = tmp;
else l->r = tmp;
l->val = tmp->val->clone();
}
l->update(x, y, v);
}
ll rv = 0;
if (l != NULL) rv = __gcd(l->val->query(y, y), rv);
if (r != NULL) rv = __gcd(r->val->query(y, y), rv);
val->update(y, rv);
}
}
RINGING_USING_NAMESPACE
RINGING_USING_STD
bool is_cyclic_le( const row &lh, int hunts )
{
const int n( lh.bells() - hunts );
// Rounds doesn't count...
if ( lh[hunts] == hunts )
return false;
{
for ( int i=0; i<hunts; ++i )
if ( lh[i] != i )
return false;
}
{
for ( int i=hunts+1; i<lh.bells(); ++i )
if ( (lh[i] - hunts) % n != (lh[i-1] + 1 - hunts) % n )
return false;
}
return true;
}
void
config_reader::parse_debug_line(row<long>& dbg_line, ch_string& str_ln){
#ifdef FULL_DEBUG
bj_ostream& os = bj_out;
MARK_USED(os);
const char* pt_in = str_ln.c_str();
dbg_line.clear();
long num_ln = 0;
if(isalnum(*pt_in)){
skip_whitespace(pt_in, num_ln);
while(isdigit(*pt_in) || isspace(*pt_in)){
if(isspace(*pt_in)){
pt_in++;
continue;
}
//os << pt_in << "$\n";
long val = parse_long(pt_in, num_ln);
//skip_whitespace(pt_in, num_ln);
dbg_line.push(val);
}
} else {
skip_line(pt_in, num_ln);
}
#endif
}
void
read_batch_instances(ch_string file_nm, row<satex_entry>& f_insts){
bj_ostream& os = bj_out;
std::ifstream in_stm;
in_stm.open(file_nm.c_str(), std::ios::binary);
if(! in_stm.good() || ! in_stm.is_open()){
os << "NO " << file_nm << " FILE FOUND." << bj_eol;
return;
}
ch_string str_ln;
long num_ln = 0;
f_insts.clear();
while(! in_stm.eof()){
std::getline(in_stm, str_ln);
num_ln++;
if(! str_ln.empty()){
satex_entry& n_inst = f_insts.inc_sz();
//os << "Lei:<<" << str_ln << ">>" << bj_eol;
n_inst.parse_entry(str_ln, num_ln);
}
}
in_stm.close();
}
ll query(int x, int y, int p1, int p2) {
int m = (s+e)/2;
if (x <= s && e <= y) return val->query(p1, p2);
ll ret = 0;
if (l != NULL && x <= m) ret = __gcd(ret, l->query(x, min(y, m), p1, p2));
if (r != NULL && y > m) ret = __gcd(ret, r->query(max(m+1, x), y, p1, p2));
return ret;
}
/*!
* initializes with values from a database row
*/
void record::init(const row &values) {
if (!values.is_valid()) {
return;
}
for (auto v = values.begin(); v != values.end(); ++v) {
set(v.name(), v->value());
}
on_record_init(values);
}
row check_solution(const matrix &A , const row &X, const row &B) {
row diff;
diff.resize(B.size());
int size = B.size();
for(int i = 0; i < size; i++) {
double temp = 0;
for(int j = 0; j < size; j++) {
temp += A[i][j] * X[j];
}
diff[i] = temp - B[i];
}
return diff;
}
int table::edit_row(const row &old_row, row new_row) {
int count = 0;
// add column data that is not included to new_row (still enables writing empty values)
for (int i=0;i<_Tstruct.size();i++) {
if (!new_row.is_defined(new_row[_Tstruct[i].name])) new_row.add(_Tstruct[i], old_row[_Tstruct[i].name]);
}
if (old_row.id >= 0) {
_fdata->seek(old_row.id*_row_size);
_write_row(new_row._data);
count++;
// if old row's key value has changed then update the key entry (insde _keys)
if (old_row[_key.name] != new_row[_key.name]) {
for (int i=0;i<_keys.size();i++) {
if (_keys[i].row_id == old_row.id) {
_keys[i].data = new_row[_key.name]; // change key entry data to represent change
break;
}
}
}
}
else {
query q;
predicate p;
for (int i=0;i<_Tstruct.size();i++) p.And( equalto(_Tstruct[i], old_row[_Tstruct[i].name]) ); // build predicate matching the row
q.where(p);
vector<row> results = select(q);
for (int i=0;i<results.size();i++) {
_fdata->seek(results[i].id * _row_size);
_write_row(new_row._data);
count++;
// if old row's key value has changed then update the key entry (insde _keys)
if (old_row[_key.name] != new_row[_key.name]) {
for (int i=0;i<_keys.size();i++) {
if (_keys[i].row_id == results[i].id) {
_keys[i].data = new_row[_key.name]; // change key entry data to represent change
break;
}
}
}
}
}
return count;
}
static bool fetch(const row& res, ColOrName col_or_name, std::unique_ptr<T>& v)
{
T tmp;
if (res.fetch(col_or_name, tmp))
v.reset(new T(std::move(tmp)));
return true;
}
void table::delete_row(const row& del_row) {
if (del_row.id >= 0) delete_row(del_row.id);
else {
predicate p;
for (int i=0;i<_Tstruct.size();i++) if (del_row.is_defined(_Tstruct[i])) p.And( equalto(_Tstruct[i], del_row[_Tstruct[i]]) ); // build predicate matching the row
delete_row(select(query().where(p)));
}
}
static bool fetch(const row& res, ColOrName col_or_name, boost::posix_time::ptime& v)
{
std::tm tm_struct;
bool ret = res.fetch(col_or_name, tm_struct);
if (ret)
v = boost::posix_time::ptime_from_tm(tm_struct);
return ret;
}
void debugEcho(const row& row_)
{
std::ostringstream doc;
doc << "<row>" << std::endl;
for(std::size_t i = 0; i != row_.size(); ++i)
{
const column_properties & props = row_.get_properties(i);
doc << " " << props.get_name();
switch(props.get_data_type())
{
case dt_string:
doc << "-string:" << row_.get<std::string>(i);
break;
case dt_double:
doc << "-double:" << row_.get<double>(i);
break;
case dt_integer:
doc << "-integer:" << row_.get<int>(i);
break;
case dt_unsigned_long:
doc << "-ulong:" << row_.get<unsigned long>(i);
break;
case dt_long_long:
doc << "-long long:" << row_.get<long long>(i);
break;
case dt_date:
std::tm when = row_.get<std::tm>(i);
doc << "-date:" << asctime(&when);
break;
}
doc << std::endl;
}
doc << "</row>" << std::endl;
std::cout << doc.str();
}
bool ck_sorted_sorsets(row<sorset*>& rr_srss, cmp_srs_func_t cmp_fn){
std::ostream& os = std::cout;
long the_sz = rr_srss.size();
if(the_sz == 0){ return true; }
sorset* lst = rr_srss[0];
for(row_index ii = 1; ii < the_sz; ii++){
sorset* srs = rr_srss[ii];
if((*cmp_fn)(lst, srs) > 0){
os << "ck_sorted_sorsets_FAILED_with" << std::endl;
os << "srs_1=" << lst << std::endl; // prt_sorset
os << "srs_2=" << srs << std::endl; // prt_sorset
return false;
}
lst = srs;
}
return true;
}
void
sql::write_extrinsic_comparison(relation r, const abstract_column_sequence &lhs, const row &rhs) {
vector<thunk> lhs_thunks;
vector<thunk> rhs_thunks;
lhs.for_each_column([&](const column_mapper &c) {
lhs_thunks.push_back([&](sql &cmd) {
cmd.write_evaluation(c);
});
const string placeholder = next_placeholder();
rhs_thunks.push_back([=](sql &cmd) {
write(placeholder);
});
attach_cell(*rhs.find_cell(c.name()));
});
write_lexicographic_comparison(r, lhs_thunks, rhs_thunks);
}
void
sql::write_values(
const abstract_mapper_base &value_mapper,
const row &data,
optional<column_id> excluded
) {
write(" VALUES (");
comma_separated_list_scope list_scope(*this);
value_mapper.for_each_persistent_column(
[&](const persistent_column_mapper &p) {
if (p.id() != excluded) {
list_scope.start_item();
write_value(*data.find_cell(p.name()));
}
}
);
write(")");
}
row solve_progon(const matrix &A,const row &B) {
row P, Q, ans;
int N = B.size();
P.resize(N);
Q.resize(N);
ans.resize(N);
P[0] = - A[0][1] / A[0][0];
Q[0] = B[0]/A[0][0];
//Pr9moy xod
for(int i = 1; i < N; i++) {
P[i] = A[i][i + 1]/(-A[i][i] - A[i][i - 1]*P[i-1]);
Q[i] = (A[i][i - 1] * Q[i - 1] - B[i]) / (-A[i][i] - A[i][i-1] * P[i - 1]);
}
//Obratniy xod
ans[N - 1] = (A[N-1][N-2] * Q[N-2] - B[N-1]) / (-A[N-1][N-1] - A[N-1][N-2] * P[N-2]);
for(int i = N - 2; i >= 0; --i) {
ans[i] = P[i] * ans[i+1] + Q[i];
}
return ans;
}
bool ck_sorted_elems(row<elem_sor*>& rr_ele, cmp_elems_func_t cmp_fn){
std::ostream& os = std::cout;
long the_sz = rr_ele.size();
if(the_sz == 0){ return true; }
elem_sor* lst = rr_ele[0];
for(row_index ii = 1; ii < the_sz; ii++){
elem_sor* ele = rr_ele[ii];
if((*cmp_fn)(lst, ele) > 0){
os << "ck_sorted_elems_FAILED_with" << std::endl;
os << "ele_1=" << *lst << std::endl;
os << "ele_2=" << *ele << std::endl;
os << "ids_1=" << lst->es_ids << std::endl;
os << "ids_2=" << ele->es_ids << std::endl;
return false;
}
lst = ele;
}
return true;
}
void
sql::write_update(
const binomen &table,
const abstract_mapper_base &dest,
const row &src,
optional<column_id> excluded
) {
// TODO: factor out the code in common with the other overload
//
write("UPDATE ");
write_quoted(table);
write(" SET ");
comma_separated_list_scope list_scope(*this);
dest.for_each_persistent_column([&](const persistent_column_mapper &p) {
if (p.id() != excluded) {
list_scope.start_item();
write_quoted(p.name());
write(" = ");
write_value(*src.find_cell(p.name()));
}
});
}
row solve(const row &left,const row &mid,const row &right, int j) {
int size = left.size();
double pt, bt;
row B(size);
matrix A(size, row(size));
for(int i = 0; i < A.size(); i++) {
if(i - 1 >=0)
A[i][i-1] = 1;
A[i][i] = -2;
if(i + 1 < A.size())
A[i][i+1] = 1;
if(i == 0)
pt = 0;
else
pt = mid[i-1];
if (i == A.size() - 1)
bt = 0;
else
bt = mid[i+1];
B[i] = (-left[i] + 2 * mid[i] - right[i]) * dt /(R * C) + (pt - 2 * mid[i] + bt) + I[j][i] * dt/C;//(left[i] - 2 * mid[i] + right[i]) * (dt / (R * C) - 1) + I[j][i] * dt / C ;
}
row s = solve_progon(A, B);
return s;
}
void print_matrix(const row &v) {
for(int i = 0; i < v.size(); i++){
std::cout << v[i] << std::endl;
}
}
void single_source_dijkstra_path_basic(Graph &G,int s,row &S,tablist &P,int* sigma,float* D)
{
/*
Graph G:G is the graph object
s:s is the source vertex.
S:S will contain the nodes in a topological order.
P:P[w] gives the predecessors of w in the DAG rooted at s.
sigma:sigma[t] gives the number of shortest paths from s to t.
D:D[t] gives the distance from s to t.
*/
float vw_dist;
onemap_d seen;
int* find=new int[G.len()];
for(int i=0;i<G.len();i++)
{
find[i]=0;
}
for(int i=0;i<G.len();i++)
{
D[i]=numeric_limits<float>::infinity();
sigma[i]=0;
}
sigma[s]=1;
seen[s]=0.0;
/*Create a priority queue*/
priority_queue<Elem,vector<Elem>,dist_compare> Q;
/*Add s to the queue*/
Elem e1(s,s,0.0);
Q.push(e1);
S.reserve(G.len()+1);
while(!Q.empty())
{
Elem e=Q.top();
Q.pop();
int v=e.node;
if(find[v]==1)
{
continue;
}
if(v!=s)
{
sigma[v]+=sigma[e.pred];
}
S.push_back (v);
D[v]=e.dist;
find[v]=1;
for (vector<Edge>::iterator it = G.adj_list[v].begin(); it != G.adj_list[v].end(); ++it)
{
int w=it->vertex;
vw_dist=e.dist+ it->weight;
if ((find[w]==0)&&((seen.find(w)==seen.end())||(vw_dist<seen[w])))
{
seen[w]=vw_dist;
Q.push( Elem(v,w,vw_dist));
sigma[w]=0;
vector<int> new_vector(1);
new_vector[0]=v;
P[w]=new_vector;
}
else if (abs(vw_dist-seen[w])<EPSILON)
{
sigma[w]+=sigma[v];
P[w].push_back(v);
}
}
}
delete[] find;
return;
}
outFileTable::outFileTable(const std::string & filename,const row & header):_fileName(filename),tableAbs(header.getDelim()){//output
//create outFileTable with this constructor ; inherits fileTable
_columnHeaders=header;
std::ofstream tmpOutFile;
tmpOutFile.open(filename, std::ios::out | std::ios::app);
if(!tmpOutFile.is_open())
{
throw std::runtime_error("Could not open file for writing.\n");
}
tmpOutFile.close();
}
