// Standard function takes the query as an input and evaluates the associated function
void KBModActionPlugin::ExecuteAtom::execute(Environment& environment,
RegistryPtr pregistry, const Tuple& parms,
const InterpretationConstPtr interpretationPtr) {
Registry& registry = *pregistry;
assert(parms.size() > 0);
std::string command;
for (int i = 0; i < parms.size(); i++) {
if (parms[i].isIntegerTerm()) {
std::ostringstream a_int;
a_int << parms[i].address;
std::string int_str = a_int.str();
command += int_str;
} else if (parms[i].isConstantTerm() || parms[i].isVariableTerm()) {
std::string termStr = registry.getTermStringByID(parms[i]);
command += termStr;
} else {
std::string termStr = registry.getTermStringByID(parms[i]);
if (termStr[0] != '\"' || termStr[termStr.size() - 1] != '\"') {
throw PluginError(
"The parameter of the atom #execute should be a quoted string!");
}
command += termStr.substr(1, termStr.size() - 2);
}
}
system(command.c_str());
}
/**
* @brief if the Tuple passed as the second parameter is present in the AnswerSets passed as first parameter
*/
bool ActionPluginFinalCallback::thisAnswerSetContainsThisAction(
const AnswerSetPtr& answerSetPtr, const Tuple& action_tuple) {
// used to have only the Action Atoms
InterpretationPtr intr = InterpretationPtr(new Interpretation(registryPtr));
intr->getStorage() |= ctxData.myAuxiliaryPredicateMask.mask()->getStorage();
intr->getStorage() &= answerSetPtr->interpretation->getStorage();
Interpretation::TrueBitIterator bit, bit_end;
for (boost::tie(bit, bit_end) = intr->trueBits(); bit != bit_end; ++bit) {
const Tuple & tuple = registryPtr->ogatoms.getByAddress(*bit).tuple;
if (tuple.size() - 5 == action_tuple.size()) {
bool different = false;
for (int i = 0; i < action_tuple.size() && !different; i++)
if (tuple[i + 1] != action_tuple[i])
different = true;
if (!different)
return true;
}
}
return false;
}
bool operator()(const Tuple &t1, const Tuple &t2) const {
vector<size_t>::const_iterator it = this->order.begin();
for (; it != this->order.end(); ++it) {
if (*it >= t1.size()) {
if (*it < t2.size()) {
return false;
}
} else if (*it >= t2.size()) {
return true;
} else if (t1[*it] != t2[*it]) {
return t1[*it] < t2[*it];
}
}
if (this->total_ordering) {
Tuple::const_iterator cit1 = t1.begin();
Tuple::const_iterator cit2 = t2.begin();
while (cit1 != t1.end() && cit2 != t2.end()) {
if (*cit1 != *cit2) {
return *cit1 < *cit2;
}
++cit1;
++cit2;
}
if (cit1 == t1.end()) {
return cit2 != t2.end();
}
}
return false;
}
Adapt::Adapt(Tuple<Space *> spaces_, Tuple<int> proj_norms) : num_act_elems(-1), have_solutions(false), have_errors(false)
{
// sanity check
if (proj_norms.size() > 0 && spaces_.size() != proj_norms.size())
error("Mismatched numbers of spaces and projection types in Adapt::Adapt().");
this->neq = spaces_.size();
// sanity checks
error_if(this->neq <= 0, "Too few components (%d), only %d supported.", this->neq, H2D_MAX_COMPONENTS);
error_if(this->neq >= H2D_MAX_COMPONENTS, "Too many components (%d), only %d supported.", this->neq, H2D_MAX_COMPONENTS);
for (int i = 0; i < this->neq; i++) {
if (spaces_[i] == NULL) error("spaces[%d] is NULL in Adapt::Adapt().", i);
this->spaces.push_back(spaces_[i]);
}
// reset values
memset(errors_squared, 0, sizeof(errors_squared));
memset(form, 0, sizeof(form));
memset(ord, 0, sizeof(ord));
memset(sln, 0, sizeof(sln));
memset(rsln, 0, sizeof(rsln));
if (proj_norms.size() > 0) {
for (int i = 0; i < this->neq; i++) {
switch (proj_norms[i]) {
case H2D_L2_NORM: form[i][i] = l2_form<double, scalar>; ord[i][i] = l2_form<Ord, Ord>; break;
case H2D_H1_NORM: form[i][i] = h1_form<double, scalar>; ord[i][i] = h1_form<Ord, Ord>; break;
case H2D_HCURL_NORM: form[i][i] = hcurl_form<double, scalar>; ord[i][i] = hcurl_form<Ord, Ord>; break;
case H2D_HDIV_NORM: form[i][i] = hdiv_form<double, scalar>; ord[i][i] = hdiv_form<Ord, Ord>; break;
default: error("Unknown projection type in Adapt::Adapt().");
}
}
}
}
/**
* \param Tuple The first numeric tuple.
* \param Tuple The second numeric tuple.
*
* \return Number The result of the dot product.
*
* If one of the tuples is shorter, the remaining of the elements will be interpreted as 0.
*/
void VEC_DOT(Machine & machine){
Number result = 0;
Tuple b = machine.stack.popTuple();
Tuple a = machine.stack.popTuple();
Size min_size = a.size() < b.size() ? a.size() : b.size();
for(Index i = 0; i < min_size; i++) result += a[i].asNumber() * b[i].asNumber();
machine.stack.push(result);
}
void Adapt::init(Tuple<Space *> sp, Tuple<ProjNormType> proj_norms)
{
_F_
this->num = sp.size();
this->proj_norms = proj_norms;
this->spaces = new Space *[this->num];
for (int i = 0; i < this->num; i++) spaces[i] = sp[i];
this->sln = new Solution *[this->num];
this->rsln = new Solution *[this->num];
this->errors = new double *[this->num];
this->norms = new double [this->num];
for (int i = 0; i < this->num; i++) {
this->sln[i] = NULL;
this->rsln[i] = NULL;
this->errors[i] = NULL;
this->norms[i] = 0.0;
}
form = new_matrix<biform_val_t>(num, num);
ord = new_matrix<biform_ord_t>(num, num);
for (int i = 0; i < num; i++)
for (int j = 0; j < num; j++) {
if (i == j && proj_norms.size() > 0) {
switch (proj_norms[i]) {
case HERMES_H1_NORM: form[i][i] = h1_form<double, scalar>; ord[i][i] = h1_form<Ord, Ord>; break;
case HERMES_HCURL_NORM: form[i][i] = hcurl_form<double, scalar>; ord[i][i] = hcurl_form<Ord, Ord>; break;
default: error("Unknown projection type in Adapt::Adapt().");
}
}
else {
form[i][j] = NULL;
ord[i][j] = NULL;
}
}
esort = NULL;
have_errors = false;
// default parameters
h_only = false;
strategy = 0;
max_order = H3D_MAX_ELEMENT_ORDER;
aniso = true;
exponent = 1.0 / 3.0;
log_file = NULL;
}
/**
* \param Tuple The first numeric tuple.
* \param Tuple The second numeric tuple.
*
* \return Tuple The result of an element wise multiplication.
*
* If one of the tuples is shorter, the remaining of the elements will be interpreted as 0.
*/
void VEC_MUL(Machine & machine){
Tuple & result = machine.globals[machine.nextInt8()].asTuple() = Tuple();
Tuple b = machine.stack.popTuple ();
Number a = machine.stack.popNumber();
for(Index i = 0; i < b.size(); i++) result.push(a * b[i].asNumber());
machine.stack.push(result);
}
template<class T> void Tuple<T>::append(const Tuple<T>& t) {
int old_sz = sz;
reallocate(t.size()+size());
assert(alloc_sz >= sz);
for(int i=0; i<t.sz; i++)
data[i+old_sz] = t.data[i];
}
void Relation::joinTuples(Schema &s1, Schema &s2, Tuple t1, Tuple t2){
Tuple t3 = t1;
for(int i = 0; i < (int)t2.size(); i++)
if(!s1.contains(s2.attributes[i]))
t3.push_back(t2[i]);
tuples.insert(t3);
}
bool Tuple::operator < (const Tuple &right) const {
if (this->size() < right.size()) {
return true;
}
if (this->size() == right.size()) {
for (std::size_t i = 0; i < this->size(); ++i) {
if ((*this)[i] < right[i]) {
return true;
}
if (right[i] < (*this)[i]) {
return false;
}
}
}
return false;
}
void TupleStorageSubBlock::paranoidInsertTypeCheck(const Tuple &tuple, const AllowedTypeConversion atc) {
#ifdef QUICKSTEP_DEBUG
assert(relation_.size() == tuple.size());
Tuple::const_iterator value_it = tuple.begin();
CatalogRelation::const_iterator attr_it = relation_.begin();
while (value_it != tuple.end()) {
switch (atc) {
case kNone:
assert(value_it->getType().equals(attr_it->getType()));
break;
case kSafe:
assert(value_it->getType().isSafelyCoercibleTo(attr_it->getType()));
break;
case kUnsafe:
assert(value_it->getType().isCoercibleTo(attr_it->getType()));
break;
}
++value_it;
++attr_it;
}
#endif
}
bool toVector(PyObjectPtr obj, std::vector<double>& result)
{
bool knownType = true;
if(NdArray::check(obj))
{
NdArray ndarray = {obj};
const unsigned size = ndarray.size();
result.resize(size);
const int ndim = ndarray.ndim();
if(ndim != 1)
throw std::runtime_error("Array object has " + std::to_string(ndim)
+ " dimensions, expected 1");
if(!ndarray.isDouble())
throw std::runtime_error("Array object does not contain doubles");
for(unsigned i = 0; i < size; i++)
result[i] = ndarray.get(i);
}
else if(List::check(obj))
{
List list = {obj};
const unsigned size = list.size();
result.resize(size);
for(unsigned i = 0; i < size; i++)
{
if(!list.isDouble(i))
throw std::runtime_error(
"List object contains item that is not a double at index "
+ std::to_string(i));
result[i] = list.get(i);
throwPythonException();
}
}
else if(Tuple::check(obj))
{
Tuple tuple = {obj};
const unsigned size = tuple.size();
result.resize(size);
for(unsigned i = 0; i < size; i++)
{
if(!tuple.isDouble(i))
throw std::runtime_error(
"Tuple object contains item that is not a double at index "
+ std::to_string(i));
result[i] = tuple.get(i);
throwPythonException();
}
}
else
{
knownType = false;
}
return knownType;
}
std::pair<ConstraintTree*,ConstraintTree*>
ConstraintTree::split (const Tuple& tuple)
{
// assumes that my log vars are already on top
LogVars lvs (logVars_.begin(), logVars_.begin() + tuple.size());
ConstraintTree tempCt (logVars_, {tuple});
return split (lvs, &tempCt, lvs);
}
bool operator()(const Tuple& tup, std::vector<size_t>& mv) const {
if ((*this)(tup)) {
mv.resize(size);
std::iota(mv.begin(), mv.end(), tup.size() - size);
return true;
}
return false;
}
// Newton's method for an arbitrary number of equations.
bool NonlinSystem::solve_newton(Tuple<Solution*> u_prev, double newton_tol,
int newton_max_iter, bool verbose,
Tuple<MeshFunction*> mesh_fns)
{
// sanity checks
int n = u_prev.size();
if (n != this->wf->neq)
error("The number of solutions in newton_solve() must match the number of equation in the PDE system.");
if (this->spaces == NULL) error("spaces is NULL in solve_newton().");
for (int i=0; i < n; i++) {
if (this->spaces[i] == NULL) error("spaces[%d] is NULL in solve_newton().", i);
}
int n_mesh_fns;
if (mesh_fns == Tuple<MeshFunction*>()) n_mesh_fns = 0;
else n_mesh_fns = mesh_fns.size();
for (int i=0; i<n_mesh_fns; i++) {
if (mesh_fns[i] == NULL) error("a filter is NULL in solve_newton().");
}
int it = 1;
double res_l2_norm;
do
{
info("---- Newton iter %d:", it);
// reinitialize filters
for (int i=0; i < n_mesh_fns; i++) mesh_fns[i]->reinit();
// assemble the Jacobian matrix and residual vector,
// solve the system
this->assemble();
this->solve(u_prev);
// calculate the l2-norm of residual vector
res_l2_norm = this->get_residual_l2_norm();
if (verbose) printf("---- Newton iter %d, ndof %d, res. l2 norm %g\n",
it, this->get_num_dofs(), res_l2_norm);
it++;
}
while (res_l2_norm > newton_tol && it <= newton_max_iter);
// returning "true" if converged, otherwise returning "false"
if (it <= newton_max_iter) return true;
else return false;
}
template<class T> bool Tuple<T>::operator == (const Tuple<T>& b) const
{
int i;
if (sz != b.size()) return false;
for (i=0; i<sz; i++)
if (!(data[i] == b[i+1])) return false;
return true;
}
template<class T> void Tuple<T>::join(Tuple<T>& t) {
int old_sz = sz;
reallocate(t.size()+size());
assert(alloc_sz >= sz);
for(int i=0; i<t.sz; i++)
data[i+old_sz] = t.data[i];
t.clear();
}
bool operator()(const Tuple& tup) const {
if (tup.size() >= size) {
auto& tarr = static_types_array<T...>::arr;
auto begin = tup.begin();
return std::equal(begin, begin + size, tarr.begin(), types_only_eq);
}
return false;
}
void Filter::init(Tuple<MeshFunction*> solutions)
{
this->num = solutions.size();
if(num > 10)
error("Attempt to create an instance of Filter with more than 10 MeshFunctions.");
for(int i = 0; i < this->num; i++)
this->sln[i] = solutions.at(i);
this->init();
}
void Paving::save(const std::string filename, const Names &titles, const Names &names) const {
if (empty()) return;
Tuple vs;
for (nat v = 0; v < names.size(); ++v) {
nat n = varbox_.var(names[v]);
if (n < nvars())
vs.push_back(n);
}
std::ostringstream os;
os << filename;
for (nat i = 0; i < vs.size(); ++i)
os << "_" << varbox_.name(vs[i]);
os << ".dat";
if (vs.empty()) {
vs.resize(varbox_.size());
for (nat v = 0; v < varbox_.size(); ++v)
vs[v] = v;
}
std::ofstream f;
f.open(os.str().c_str(), std::ofstream::out);
f << "## File: " << os.str() << std::endl;
f << "## Type: " << type_ << std::endl;
f << "## Vars:" << std::endl;
nat width = 2 * Kodiak::precision();
for (nat i = 0; i < vs.size(); ++i)
f << std::setw(width) << varbox_.name(vs[i]);
f << std::endl;
for (nat i = 0; i < vs.size(); ++i)
f << std::setw(width) << varbox_.box()[vs[i]].inf();
f << std::endl;
for (nat i = 0; i < vs.size(); ++i)
f << std::setw(width) << varbox_.box()[vs[i]].sup();
f << std::endl;
f << std::endl;
for (nat i = 0; i < titles.size(); ++i) {
f << "## " << titles[i] << ": " << size(i) << " boxes " << std::endl;
if (i < boxes_.size() && boxes_[i].size() > 0)
save_boxes(f, boxes_[i], vs, width);
else
f << std::endl;
}
f.close();
std::cout << "Kodiak (save): Boxes were saved in file " << os.str() << std::endl;
}
/**
* \param Tuple The first numeric tuple.
* \param Tuple The second numeric tuple.
*
* \return Tuple The result of an element wise addition.
*
* If one of the tuples is shorter, the remaining of the elements will be interpreted as 0.
*/
void VEC_ADD(Machine & machine){
Tuple b = machine.stack.popTuple();
Tuple a = machine.stack.popTuple();
Size min_size = a.size() < b.size() ? a.size() : b.size();
Size max_size = a.size() < b.size() ? b.size() : a.size();
Tuple & largest = a.size() < b.size() ? b : a;
Tuple result(max_size);
for(Index i = 0 ; i < min_size; i++) result.push(a[i].asNumber() + b[i].asNumber());
for(Index i = min_size; i < max_size; i++) result.push(largest[i].asNumber());
machine.stack.push(result);
}
/// \deprecated_mitproto{VEC_ADD}
void VADD(Machine & machine){
Tuple b = machine.stack.popTuple();
Tuple a = machine.stack.popTuple();
Size min_size = a.size() < b.size() ? a.size() : b.size();
Size max_size = a.size() < b.size() ? b.size() : a.size();
Tuple & largest = a.size() < b.size() ? b : a;
Tuple & result = machine.globals[machine.nextInt8()].asTuple() = Tuple(max_size);
for(Index i = 0 ; i < min_size; i++) result.push(a[i].asNumber() + b[i].asNumber());
for(Index i = min_size; i < max_size; i++) result.push(largest[i].asNumber());
machine.stack.push(result);
}
void LinearProblem::set_spaces(Tuple<Space *> sp)
{
_F_
int n = sp.size();
if (n <= 0 || n > wf->neq) EXIT("Bad number of spaces.");
if (n != this->wf->neq)
error("Number of spaces must match the number of equations in LinearProblem::set_spaces()");
for (int i = 0; i < n; i++) spaces[i] = sp[i];
memset(sp_seq, -1, sizeof(int) * wf->neq);
}
/**
* \param Tuple The numeric tuple to substract from.
* \param Tuple The numeric tuple to substract.
*
* \return Tuple The result of an element wise subtraction.
*
* If one of the tuples is shorter, the remaining of the elements will be interpreted as 0.
*/
void VEC_SUB(Machine & machine){
Tuple b = machine.stack.popTuple();
Tuple a = machine.stack.popTuple();
Size min_size = a.size() < b.size() ? a.size() : b.size();
Size max_size = a.size() < b.size() ? b.size() : a.size();
Tuple & largest = a.size() < b.size() ? b : a ;
Number padding_sign = a.size() < b.size() ? -1 : 1 ;
Tuple result(max_size);
for(Index i = 0 ; i < min_size; i++) result.push(a[i].asNumber() - b[i].asNumber());
for(Index i = min_size; i < max_size; i++) result.push(padding_sign * largest[i].asNumber());
machine.stack.push(result);
}
/// \deprecated_mitproto
void VSLICE(Machine & machine){
Tuple & result = machine.globals[machine.nextInt8()].asTuple() = Tuple();
Tuple source = machine.stack.popTuple();
Index start = machine.stack.popNumber();
Index stop = machine.stack.popNumber();
start = start >= 0 ? start : source.size() + start;
stop = stop >= 0 ? stop : source.size() + stop ;
for(Index i = start; i < stop; i++) result.push(source[i].asNumber());
machine.stack.push(result);
}
NonlinSystem::NonlinSystem(WeakForm* wf_, CommonSolver* solver_, Tuple<Space*> spaces_)
{
int n = spaces_.size();
if (n != wf_->neq)
error("Number of spaces does not match number of equations in LinSystem::LinSystem().");
this->init_lin(wf_, solver_);
this->init_spaces(spaces_);
//this->alloc_and_zero_vectors();
this->init_nonlin();
}
Tuple Database::joinTuple(set<pair<int, int>> pairs, Tuple t1, Tuple t2){
Tuple newTuple;
for (int i = 0; i<t1.size(); i++){
newTuple.push_back(t1[i]);
}
for (auto i : t2){
newTuple.push_back(i);
}
return newTuple;
}
bool operator()(const Tuple& tup) const {
auto& tarr = static_types_array<T...>::arr;
if (tup.size() >= (sizeof...(T) - wc_count)) {
auto fpush = [](const typename Tuple::const_iterator&) {};
auto fcommit = [] {};
auto frollback = [] {};
return match(tup.begin(), tup.end(), tarr.begin(), tarr.end(),
fpush, fcommit, frollback);
}
return false;
}
elimination_info::elimination_info(const Tuple<Relation> &sets) {
int max_arity=0;
for(int i = 1; i <= sets.size(); i++) {
Relation R = sets[i];
assert(R.is_set());
for(DNF_Iterator D(R.query_DNF()); D; D++)
for(Constraint_Iterator c(*D); c; c++)
max_arity = omega::max(max_arity,max_fs_arity(*c));
}
never_eliminate_lt = max_arity;
}
bool Tuple::operator == (const Tuple &right) const {
if (this->size() != right.size()) {
return false;
}
for (std::size_t i = 0; i < this->size(); ++i) {
if ((*this)[i] != right[i]) {
return false;
}
}
return true;
}
