/*
* Adds the given Contraint to the appropriate ConstraintSet.
*/
void
ReqValidatorConstraints::add (VConstraint* c)
{
if (c == NULL) return;
ptrMap.insert(pair<VConstraint*,bool>(c,true));
if (dynamic_cast< TConstraint<SBMLDocument>* >(c) != NULL)
{
mSBMLDocument.add( static_cast< TConstraint<SBMLDocument>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Model>* >(c) != NULL)
{
mModel.add( static_cast< TConstraint<Model>* >(c) );
return;
}
if (dynamic_cast< TConstraint<ChangedMath>* >(c) != NULL)
{
mChangedMath.add( static_cast< TConstraint<ChangedMath>* >(c) );
return;
}
}
string MuscleOptimizer::getIndependentCoordinate(Model& model, const std::string& dofName)
{
ConstraintSet constraintSet = model.getConstraintSet();
for (int n = 0; n < constraintSet.getSize(); ++n)
{
CoordinateCouplerConstraint* constraint = dynamic_cast<CoordinateCouplerConstraint*>(&constraintSet.get(n));
if (constraint != NULL) // we can only handle this type of constraint, so we just skip the others
{
string depCoordinateName = constraint->getDependentCoordinateName();
if (depCoordinateName == dofName)
{
const Array<std::string>& indepCoordinateNamesSet = constraint->getIndependentCoordinateNames();
if (indepCoordinateNamesSet.getSize() == 1)
{
return indepCoordinateNamesSet.get(0);
}
else if (indepCoordinateNamesSet.getSize() > 1)
{
std::cout << "CoordinateCouplerConstraint with dependent coordinate " << dofName << " has more than one indipendent coordinate and this is not managed by this software yet." << std::endl;
return "";
}
}
}
}
return "";
}
/*
* Adds the given Contraint to the appropriate ConstraintSet.
*/
void
ArraysValidatorConstraints::add (VConstraint* c)
{
if (c == NULL) return;
ptrMap.insert(pair<VConstraint*,bool>(c,true));
if (dynamic_cast< TConstraint<SBMLDocument>* >(c) != NULL)
{
mSBMLDocument.add( static_cast< TConstraint<SBMLDocument>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Model>* >(c) != NULL)
{
mModel.add( static_cast< TConstraint<Model>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Dimension>* >(c) != NULL)
{
mDimension.add( static_cast< TConstraint<Dimension>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Index>* >(c) != NULL)
{
mIndex.add( static_cast< TConstraint<Index>* >(c) );
return;
}
}
bool CreateDesertConstraintSet(ConstraintSet &cs, UdmDesertMap &des_map, DesertUdmMap &inv_des_map )
{
bool ret = true;
Constraint ct;
Element owner;
long cts_id;
set<Constraint> ct_set = cs.Constraint_children();
set<Constraint>::iterator ct_iterator;
ASSERT(!ct_set.empty());
//create constraint set
cts_id = CreateConstraintSet(utf82cstring((string)cs.name()));
DoMap(cs, des_map, inv_des_map, cts_id);
for(ct_iterator = ct_set.begin(); ct_iterator != ct_set.end(); ct_iterator++)
{
//get owner element
ct = *(ct_iterator);
owner = ct.context();
std::string aa = owner.name();
//lookup in the map
long owner_id = GetID(owner, des_map);
//create constraint
long ct_id = CreateConstraint(utf82cstring((string)ct.name()),
cts_id,
owner_id,
utf82cstring((string)ct.expression()));
/*
long ct_id = CreateConstraint(((string)ct.name()).c_str(),
cts_id,
owner_id,
((string)ct.expression()).c_str(),
ct.id(),
ct.externalID());
*/
if(ct_id==-1) ret = false;
DoMap(ct, des_map, inv_des_map, ct_id);
}//eo for (ct_iterator)
return ret;
};//eo bool CreateDesertConstrainSet
bool CreateConstraints(DesertSystem &ds, UdmDesertMap &des_map, DesertUdmMap &inv_des_map)
{
//constrainsets, constrainst
set<ConstraintSet> c_sets = ds.ConstraintSet_kind_children();
set<ConstraintSet>::iterator cts_iterator;
if (!c_sets.empty())
{
ConstraintSet cs;
for (cts_iterator = c_sets.begin(); cts_iterator != c_sets.end(); cts_iterator++)
{
cs = *(cts_iterator);
set<Constraint> ct_set = cs.Constraint_kind_children();
if (ct_set.empty()) continue;
CreateDesertConstraintSet(cs, des_map, inv_des_map);
}//eo for cts_iterator
}//eo if (!c_sets.empty())
return true;
};
/*
* Adds the given Contraint to the appropriate ConstraintSet.
*/
void
GroupsValidatorConstraints::add (VConstraint* c)
{
if (c == NULL) return;
ptrMap.insert(pair<VConstraint*,bool>(c,true));
if (dynamic_cast< TConstraint<SBMLDocument>* >(c) != NULL)
{
mSBMLDocument.add( static_cast< TConstraint<SBMLDocument>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Model>* >(c) != NULL)
{
mModel.add( static_cast< TConstraint<Model>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Member>* >(c) != NULL)
{
mMember.add( static_cast< TConstraint<Member>* >(c) );
return;
}
if (dynamic_cast< TConstraint<MemberConstraint>* >(c) != NULL)
{
mMemberConstraint.add( static_cast< TConstraint<MemberConstraint>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Group>* >(c) != NULL)
{
mGroup.add( static_cast< TConstraint<Group>* >(c) );
return;
}
}
/*
* Adds the given Contraint to the appropriate ConstraintSet.
*/
void
DistribValidatorConstraints::add (VConstraint* c)
{
if (c == NULL) return;
ptrMap.insert(pair<VConstraint*,bool>(c,true));
if (dynamic_cast< TConstraint<SBMLDocument>* >(c) != NULL)
{
mSBMLDocument.add( static_cast< TConstraint<SBMLDocument>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Model>* >(c) != NULL)
{
mModel.add( static_cast< TConstraint<Model>* >(c) );
return;
}
if (dynamic_cast< TConstraint<DrawFromDistribution>* >(c) != NULL)
{
mDrawFromDistribution.add( static_cast< TConstraint<DrawFromDistribution>* >(c) );
return;
}
if (dynamic_cast< TConstraint<DistribInput>* >(c) != NULL)
{
mDistribInput.add( static_cast< TConstraint<DistribInput>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Uncertainty>* >(c) != NULL)
{
mUncertainty.add( static_cast< TConstraint<Uncertainty>* >(c) );
return;
}
}
/*
* Adds the given Contraint to the appropriate ConstraintSet.
*/
void
QualValidatorConstraints::add (VConstraint* c)
{
if (c == NULL) return;
ptrMap.insert(pair<VConstraint*,bool>(c,true));
if (dynamic_cast< TConstraint<SBMLDocument>* >(c) != NULL)
{
mSBMLDocument.add( static_cast< TConstraint<SBMLDocument>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Model>* >(c) != NULL)
{
mModel.add( static_cast< TConstraint<Model>* >(c) );
return;
}
if (dynamic_cast< TConstraint<QualitativeSpecies>* >(c) != NULL)
{
mQualitativeSpecies.add( static_cast< TConstraint<QualitativeSpecies>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Transition>* >(c) != NULL)
{
mTransition.add( static_cast< TConstraint<Transition>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Input>* >(c) != NULL)
{
mInput.add( static_cast< TConstraint<Input>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Output>* >(c) != NULL)
{
mOutput.add( static_cast< TConstraint<Output>* >(c) );
return;
}
if (dynamic_cast< TConstraint<FunctionTerm>* >(c) != NULL)
{
mFunctionTerm.add( static_cast< TConstraint<FunctionTerm>* >(c) );
return;
}
if (dynamic_cast< TConstraint<DefaultTerm>* >(c) != NULL)
{
mDefaultTerm.add( static_cast< TConstraint<DefaultTerm>* >(c) );
return;
}
if (dynamic_cast< TConstraint<ListOfFunctionTerms>* >(c) != NULL)
{
mListOfFunctionTerms.add( static_cast< TConstraint<ListOfFunctionTerms>* >(c) );
return;
}
}
/*
* Adds the given Contraint to the appropriate ConstraintSet.
*/
void
ValidatorConstraints::add (VConstraint* c)
{
ptrMap.insert(pair<VConstraint*,bool>(c,true));
if (dynamic_cast< TConstraint<SBMLDocument>* >(c))
{
mSBMLDocument.add( static_cast< TConstraint<SBMLDocument>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Model>* >(c))
{
mModel.add( static_cast< TConstraint<Model>* >(c) );
return;
}
if (dynamic_cast< TConstraint<FunctionDefinition>* >(c))
{
mFunctionDefinition.add
(
static_cast< TConstraint<FunctionDefinition>* >(c)
);
return;
}
if (dynamic_cast< TConstraint<UnitDefinition>* >(c))
{
mUnitDefinition.add( static_cast< TConstraint<UnitDefinition>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Unit>* >(c))
{
mUnit.add( static_cast< TConstraint<Unit>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Compartment>* >(c))
{
mCompartment.add( static_cast< TConstraint<Compartment>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Species>* >(c))
{
mSpecies.add( static_cast< TConstraint<Species>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Parameter>* >(c))
{
mParameter.add( static_cast< TConstraint<Parameter>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Rule>* >(c))
{
mRule.add( static_cast< TConstraint<Rule>* >(c) );
return;
}
if (dynamic_cast< TConstraint<AlgebraicRule>* >(c))
{
mAlgebraicRule.add( static_cast< TConstraint<AlgebraicRule>* >(c) );
return;
}
if (dynamic_cast< TConstraint<AssignmentRule>* >(c))
{
mAssignmentRule.add( static_cast< TConstraint<AssignmentRule>* >(c) );
return;
}
if (dynamic_cast< TConstraint<RateRule>* >(c))
{
mRateRule.add( static_cast< TConstraint<RateRule>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Reaction>* >(c))
{
mReaction.add( static_cast< TConstraint<Reaction>* >(c) );
return;
}
if (dynamic_cast< TConstraint<KineticLaw>* >(c))
{
mKineticLaw.add( static_cast< TConstraint<KineticLaw>* >(c) );
return;
}
if (dynamic_cast< TConstraint<SimpleSpeciesReference>* >(c))
{
mSimpleSpeciesReference.add
(
static_cast< TConstraint<SimpleSpeciesReference>* >(c)
);
/* forces constraints to be applied to modifiers */
mModifierSpeciesReference.add
(
static_cast< TConstraint<ModifierSpeciesReference>* >(c)
);
return;
}
if (dynamic_cast< TConstraint<SpeciesReference>* >(c))
{
mSpeciesReference.add
(
static_cast< TConstraint<SpeciesReference>* >(c)
);
/* forces constraints to be applied to modifiers */
mModifierSpeciesReference.add
(
static_cast< TConstraint<ModifierSpeciesReference>* >(c)
);
return;
}
if (dynamic_cast< TConstraint<ModifierSpeciesReference>* >(c))
{
mModifierSpeciesReference.add
(
static_cast< TConstraint<ModifierSpeciesReference>* >(c)
);
return;
}
if (dynamic_cast< TConstraint<Event>* >(c))
{
mEvent.add( static_cast< TConstraint<Event>* >(c) );
return;
}
if (dynamic_cast< TConstraint<EventAssignment>* >(c))
{
mEventAssignment.add( static_cast< TConstraint<EventAssignment>* >(c) );
return;
}
if (dynamic_cast< TConstraint<InitialAssignment>* >(c))
{
mInitialAssignment.add( static_cast< TConstraint<InitialAssignment>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Constraint>* >(c))
{
mConstraint.add( static_cast< TConstraint<Constraint>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Trigger>* >(c))
{
mTrigger.add( static_cast< TConstraint<Trigger>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Delay>* >(c))
{
mDelay.add( static_cast< TConstraint<Delay>* >(c) );
return;
}
if (dynamic_cast< TConstraint<CompartmentType>* >(c))
{
mCompartmentType.add( static_cast< TConstraint<CompartmentType>* >(c) );
return;
}
if (dynamic_cast< TConstraint<SpeciesType>* >(c))
{
mSpeciesType.add( static_cast< TConstraint<SpeciesType>* >(c) );
return;
}
}
static int xBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo) {
auto *pVtab = (VirtualTable *)tab;
ConstraintSet constraints;
// Keep track of the index used for each valid constraint.
// Expect this index to correspond with argv within xFilter.
size_t expr_index = 0;
// If any constraints are unusable increment the cost of the index.
double cost = 1;
// Expressions operating on the same virtual table are loosely identified by
// the consecutive sets of terms each of the constraint sets are applied onto.
// Subsequent attempts from failed (unusable) constraints replace the set,
// while new sets of terms append.
if (pIdxInfo->nConstraint > 0) {
for (size_t i = 0; i < static_cast<size_t>(pIdxInfo->nConstraint); ++i) {
// Record the term index (this index exists across all expressions).
const auto &constraint_info = pIdxInfo->aConstraint[i];
#if defined(DEBUG)
plan("Evaluating constraints for table: " + pVtab->content->name +
" [index=" + std::to_string(i) + " column=" +
std::to_string(constraint_info.iColumn) + " term=" +
std::to_string((int)constraint_info.iTermOffset) + " usable=" +
std::to_string((int)constraint_info.usable) + "]");
#endif
if (!constraint_info.usable) {
// A higher cost less priority, prefer more usable query constraints.
cost += 10;
continue;
}
// Lookup the column name given an index into the table column set.
if (constraint_info.iColumn < 0 ||
static_cast<size_t>(constraint_info.iColumn) >=
pVtab->content->columns.size()) {
cost += 10;
continue;
}
const auto &name = pVtab->content->columns[constraint_info.iColumn].first;
// Save a pair of the name and the constraint operator.
// Use this constraint during xFilter by performing a scan and column
// name lookup through out all cursor constraint lists.
constraints.push_back(
std::make_pair(name, Constraint(constraint_info.op)));
pIdxInfo->aConstraintUsage[i].argvIndex = ++expr_index;
#if defined(DEBUG)
plan("Adding constraint for table: " + pVtab->content->name +
" [column=" + name + " arg_index=" + std::to_string(expr_index) +
"]");
#endif
}
}
pIdxInfo->idxNum = kConstraintIndexID++;
// Add the constraint set to the table's tracked constraints.
#if defined(DEBUG)
plan("Recording constraint set for table: " + pVtab->content->name +
" [cost=" + std::to_string(cost) + " size=" +
std::to_string(constraints.size()) + " idx=" +
std::to_string(pIdxInfo->idxNum) + "]");
#endif
pVtab->content->constraints[pIdxInfo->idxNum] = std::move(constraints);
pIdxInfo->estimatedCost = cost;
return SQLITE_OK;
}
bool LeoModel::loadConstraintSetsFromFile (const char* filename, bool verbose) {
// initialize Constraint Sets
LuaTable lua_table = LuaTable::fromFile (filename);
vector<LuaKey> constraint_set_keys = lua_table["constraint_sets"].keys();
vector<string> constraint_set_names;
for (size_t i = 0; i < constraint_set_keys.size(); i++) {
if (constraint_set_keys[i].type == LuaKey::String) {
constraint_set_names.push_back (constraint_set_keys[i].string_value);
}
else {
cerr << "Found invalid constraint set name, string expected!" << endl;
abort();
}
}
for (size_t si = 0; si < constraint_set_names.size(); si++) {
string set_name_str = constraint_set_names[si];
if (verbose) {
cout << "ConstraintSet '" << set_name_str << endl;
}
unsigned int constraint_count =
lua_table["constraint_sets"][constraint_set_names[si].c_str()].length();
ConstraintSet cs;
ConstraintSetInfo csi;
csi.name = set_name_str;
csi.constraints.resize (constraint_count);
for (int ci = 0; ci < constraint_count; ci++) {
ConstraintInfo constraint_info =
lua_table["constraint_sets"][set_name_str.c_str()][ci + 1];
string point_name = constraint_info.point_name.c_str();
constraint_info.point_id = ci;
if (verbose) {
cout << " Adding Constraint point: " << points[point_name].name << endl;
cout << " body id = " << points[point_name].body_id << endl;
cout << " normal = [" << constraint_info.normal.transpose() << "]" << endl;
}
cs.AddConstraint (
points[point_name].body_id,
points[point_name].point_local,
constraint_info.normal
);
csi.constraints[ci] = constraint_info;
}
// save constraint set infos
constraintSetInfos[set_name_str] = csi;
// assign constraint set
constraints[set_name_str] = cs;
// TODO check which solver works better
constraints[set_name_str].linear_solver = LinearSolverHouseholderQR;
// constraintSets[set_name].linear_solver = LinearSolverPartialPivLU;
constraints[set_name_str].Bind (model);
}
// check whether we missed some sets
if (constraints.size() != constraint_set_names.size()) {
cerr << "Error: not all constraint sets have been loaded!" << endl;
abort();
}
return true;
}
void checkTypes() {
VariableIdMapping variableIdMapping;
PState s1;
cout << "RUNNING CHECKS:"<<endl;
{
// check temporary variables (create and delete)
VariableId var_tmp=variableIdMapping.createUniqueTemporaryVariableId("tmp");
variableIdMapping.deleteUniqueTemporaryVariableId(var_tmp);
}
{
cout << "------------------------------------------"<<endl;
cout << "RUNNING CHECKS FOR BOOLLATTICE TYPE:"<<endl;
AType::BoolLattice a;
a=true;
check("a=true => isTrue",a.isTrue());
AType::BoolLattice b;
b=false;
check("b=false => isFalse",b.isFalse());
AType::BoolLattice c=a||b;
check("c=a||b => c isTrue ",c.isTrue());
AType::Top e;
AType::BoolLattice d;
d=e;
check("Top e; d=e => d isTop",d.isTop());
c=c||d;
check("c=c||d: true",c.isTrue());
AType::BoolLattice f=AType::Bot();
d=AType::Bot();
check("d=bot: bot",d.isBot());
check("f=bot: bot",f.isBot());
a=d&&f;
check("a=d&&f => a isBot",a.isBot());
f=false;
check("f=false => f isFalse",f.isFalse());
a=d&&f;
check("a=d&&f: a isFalse (we define it this way)",a.isFalse());
}
{
cout << "RUNNING CHECKS FOR CONSTINT LATTICE TYPE:"<<endl;
AType::ConstIntLattice a;
a=true;
check("a=true => isTrue",a.isTrue());
check("a=true => !isFalse",!a.isFalse());
AType::ConstIntLattice b;
b=false;
check("b=false => isFalse",b.isFalse());
check("b=false => !isTrue",!b.isTrue());
AType::ConstIntLattice c=a.operatorOr(b);
check("c=a.operatorOr(b): ",c.isTrue());
AType::Top e;
AType::ConstIntLattice d;
d=e;
check("Top e; d=e; d isTop ",d.isTop());
c=c.operatorOr(d);
check("c=c.operatorOr(d) => c isTrue ",c.isTrue());
AType::ConstIntLattice f=AType::Bot();
d=AType::Bot();
a=d.operatorAnd(f);
check("d=bot;f=bot;a=d.operatorAnd(f); => a isBot",a.isBot());
f=false;
a=d.operatorAnd(f);
check("f=false; a=d.operatorAnd(f); => a isFalse",a.isFalse());
a=5;
check("a=5; a.isTrue()==true",a.isTrue()==true);
check("a=5; a.isFalse()==false",a.isFalse()==false);
a=0;
check("a=0; a.isTrue()==false",a.isTrue()==false);
check("a=0; a.isFalse())==true",a.isFalse()==true);
}
{
cout << "------------------------------------------"<<endl;
cout << "RUNNING CHECKS FOR CONSTRAINT TYPE:"<<endl;
VariableId var_x=variableIdMapping.createUniqueTemporaryVariableId("x");
VariableId var_y=variableIdMapping.createUniqueTemporaryVariableId("y");
cout << "P1"<<endl;
Constraint c1(Constraint::EQ_VAR_CONST,var_x,1);
cout << "P2"<<endl;
Constraint c2(Constraint::NEQ_VAR_CONST,var_y,2);
cout << "P3"<<endl;
Constraint c3=DISEQUALITYCONSTRAINT;
cout << "P4"<<endl;
Constraint c4=Constraint(Constraint::EQ_VAR_CONST,var_y,2);
cout << "P5"<<endl;
ConstraintSet cs;
cout << "P6"<<endl;
cs.addConstraint(c1);
cout << "P7"<<endl;
cout << "CS1:"<<cs.toString()<<endl;
cs.addConstraint(c2);
cout << "CS2:"<<cs.toString()<<endl;
check("inserted 2 different constraints, size of constraint set == 3",cs.size()==2);
check("c1:constraintExists(EQ_VAR_CONST,x,1) == true",cs.constraintExists(Constraint::EQ_VAR_CONST,var_x,1));
check("c1:constraintExists(NEQ_VAR_CONST,x,1) == false",!cs.constraintExists(Constraint::NEQ_VAR_CONST,var_x,1));
check("c2:constraintExists(NEQ_VAR_CONST,y,2) == true",cs.constraintExists(Constraint::NEQ_VAR_CONST,var_y,2));
check("c3:isDisequality==false",cs.disequalityExists()==false);
cout << "CS3:"<<cs.toString()<<endl;
cs.addConstraint(c4);
cout << "CS4:"<<cs.toString()<<endl;
cout << "P8"<<endl;
//cout << "CS:"<<cs.toString()<<endl;
check("insert y==2; => disequalityExists() == true",cs.disequalityExists());
cout << "P9"<<endl;
cs.addConstraint(c3);
check("added disequality => disequalityExists() == true",cs.disequalityExists());
check("Disequality exists <=> size()==1",cs.size()==1);
check("c1!=c2",c1!=c2);
check("c1!=c3",c1!=c3);
check("c2!=c3",c2!=c3);
{
// check for equalities
{
Constraint c1(Constraint::EQ_VAR_CONST,var_x,1);
Constraint c2=Constraint(Constraint::EQ_VAR_CONST,var_y,2);
ConstraintSet cs1;
cs1.addConstraint(c1);
cs1.addConstraint(c2);
Constraint c5(Constraint::EQ_VAR_VAR,var_x,var_y);
cs1.addConstraint(c5);
check("cs1.disequalityExists()==true",cs1.disequalityExists());
}
{
Constraint c1(Constraint::NEQ_VAR_CONST,var_x,1);
Constraint c2=Constraint(Constraint::NEQ_VAR_CONST,var_x,2);
Constraint c3=Constraint(Constraint::NEQ_VAR_CONST,var_y,3);
ConstraintSet cs1;
cs1.addConstraint(c1);
cs1.addConstraint(c2);
cs1.addConstraint(c3);
Constraint c5(Constraint::EQ_VAR_VAR,var_x,var_y);
cs1.addConstraint(c5);
check("c5:constraintExists(EQ_VAR_VAR,x,y) == true",cs1.constraintExists(Constraint(Constraint::EQ_VAR_VAR,var_x,var_y)));
check("c1:constraintExists(EQ_VAR_CONST,x,1) == false",cs1.constraintExists(Constraint::EQ_VAR_CONST,var_x,1)==false);
check("c1:constraintExists(NEQ_VAR_CONST,x,1) == true",cs1.constraintExists(Constraint::NEQ_VAR_CONST,var_x,1)==true);
check("c1:constraintExists(EQ_VAR_CONST,y,2) == false",cs1.constraintExists(Constraint::EQ_VAR_CONST,var_y,2)==false);
check("c1:constraintExists(NEQ_VAR_CONST,y,2) == true",cs1.constraintExists(Constraint::NEQ_VAR_CONST,var_y,2)==true);
cs1.removeAllConstraintsOfVar(var_x);
cs1.removeAllConstraintsOfVar(var_y);
cs1.removeAllConstraintsOfVar(var_x);
}
}
ConstraintSet cs1;
cs1.addConstraint(c1);
ConstraintSet cs2;
cs2.addConstraint(c2);
check("cs1!=cs2)",cs1!=cs2);
{
Constraint c1(Constraint::NEQ_VAR_CONST,var_y,1);
Constraint c2(Constraint::NEQ_VAR_CONST,var_y,3);
Constraint c3(Constraint::NEQ_VAR_CONST,var_y,5);
Constraint c4a(Constraint::EQ_VAR_CONST,var_y,6);
Constraint c4b(Constraint::EQ_VAR_CONST,var_y,3);
ConstraintSet cs1;
ConstraintSet cs2;
PState s;
cs1.addConstraint(c1);
cs1.addConstraint(c2);
cs1.addConstraint(c3);
cs2.addConstraint(c1);
cs2.addConstraint(c3);
check("cs1!=cs2",cs1!=cs2);
check("!(cs1==cs2)",!(cs1==cs2));
check("!(cs1<cs2)",!(cs1<cs2));
check("cs1>cs2",(cs2<cs1));
EStateSet es;
EState es1=EState(1,&s,&cs1);
es.processNewOrExisting(es1);
EState es2=EState(1,&s,&cs2);
es.processNewOrExisting(es2);
check("es.size()==2",es.size()==2);
{
Constraint c5(Constraint::EQ_VAR_CONST,var_y,10);
cs1.addConstraint(c5);
check("constraintExists(NEQ_VAR_CONST,y,1) == false",cs1.constraintExists(Constraint::NEQ_VAR_CONST,var_y,1)==false);
check("constraintExists(NEQ_VAR_CONST,y,3) == false",cs1.constraintExists(Constraint::NEQ_VAR_CONST,var_y,3)==false);
check("constraintExists(NEQ_VAR_CONST,y,5) == false",cs1.constraintExists(Constraint::NEQ_VAR_CONST,var_y,5)==false);
check("cs1.size()==1",cs1.size()==1);
}
}
}
{
cout << "------------------------------------------"<<endl;
cout << "RUNNING CHECKS FOR CONSTINTLATTICE (formerly CPPCAPSULE):"<<endl;
AType::ConstIntLattice cint1(1);
check("cint1 == 1",cint1.getIntValue()==1);
AType::ConstIntLattice cint2=AType::Top();
AType::ConstIntLattice cint3;
cint3=AType::Top();
check("cint2 isTop",cint2.isTop());
check("cint3 isTop",cint3.isTop());
check("!(cint1 == cint3)",!(cint1==cint3)); // strictly weak ordering test
check("cint2 == cint3",cint2==cint3); // strictly weak ordering test
}
{
cout << "------------------------------------------"<<endl;
cout << "RUNNING CHECKS FOR PSTATE AND PSTATESET:"<<endl;
VariableIdMapping variableIdMapping;
EState es1;
EState es2;
PState s0;
PState s1;
PState s2;
PState s3;
PState s5;
AValue valtop=AType::Top();
AValue val1=500;
AValue val2=501;
PStateSet pstateSet;
VariableId x=variableIdMapping.createUniqueTemporaryVariableId("x");
VariableId y=variableIdMapping.createUniqueTemporaryVariableId("y");
check("var x not in pstate1",s1.varExists(x)==false);
check("var y not in pstate2",s2.varExists(y)==false);
s1[x]=val1;
s2[y]=val2;
s3[x]=val2;
s5[x]=valtop;
s5[y]=valtop;
check("var x exists in pstate s1",s1.varExists(x)==true);
check("var x==500",((s1[x].operatorEq(val1)).isTrue())==true);
check("var y exists in pstate s2",s2.varExists(y)==true);
check("var y==501",((s2[y].operatorEq(val2)).isTrue())==true);
//check("s0 < s1",(s0<s1)==true);
//check("s0 < s2",(s0<s2)==true);
check("!(s1 == s2)",(s1==s2)==false);
check("s1<s2 xor s2<s1)",(s1<s2)^(s2<s1));
check("var x in pstate s3",s3.varExists(x)==true);
check("s3[x]==501",((s3[x].operatorEq(val2)).isTrue())==true);
check("!(s1==s2)",(!(s1==s2))==true);
check("!(s1==s3)",(!(s1==s3))==true);
check("!(s2==s3)",(!(s2==s3))==true);
PState s4=s1;
check("s1==s4",(s1==s4)==true);
s1[x]=val2;
check("s1.size()==1",s1.size()==1);
pstateSet.process(s0);
check("empty pstate s0 inserted in pstateSet => size of pstateSet == 1",pstateSet.size()==1);
pstateSet.process(s1);
check("s1 inserted in pstateSet => size of pstateSet == 2",pstateSet.size()==2);
pstateSet.process(s1);
check("s1 reinserted in pstateSet => size remains the same",pstateSet.size()==2);
pstateSet.process(s2);
check("s2 inserted => size of pstateSet == 3",pstateSet.size()==3);
const PState* pstateptr0=pstateSet.processNewOrExisting(s0); // version 1
check("obtain pointer to s0 from pstateSet and check !=0",pstateptr0!=0);
check("check pointer refers indeed to s0 (operator==)",(*pstateptr0)==s0);
const PState* pstateptr1=pstateSet.processNewOrExisting(s1); // version 1
check("obtain pointer to s1 from pstateSet and check !=0",pstateptr1!=0);
const PState* pstateptr2=pstateSet.processNewOrExisting(s2); // version 1
check("obtain pointer to s2 from pstateSet and check !=0",pstateptr2!=0);
check("check pstate.exists(s0)",pstateSet.exists(s0));
check("check pstate.exists(s1)",pstateSet.exists(s1));
check("check pstate.exists(s2)",pstateSet.exists(s2));
check("check !pstate.exists(s5) [s5 does not exist]",!pstateSet.exists(s5));
check("constint-strictWeak-equality-1",strictWeakOrderingIsEqual(val1,val2)==false);
check("constint-strictWeak-smaller-1",strictWeakOrderingIsSmaller(val1,val2)==true);
s4[x]=valtop;
check("created s4; inserted x=top; s4[x].isTop",s4[x].isTop());
pstateSet.processNewOrExisting(s4);
check("inserted s4 => size of pstateSet == 4",pstateSet.size()==4);
const PState* pstateptr4=pstateSet.processNewOrExisting(s4); // version 1
check("obtain pointer to s4 from pstateSet and check !=0",pstateptr4!=0);
#if 1
EStateSet eStateSet;
EState es3;
ConstraintSetMaintainer csm;
ConstraintSet cs1;
cs1.addConstraint(Constraint(Constraint::NEQ_VAR_CONST,x,1));
const ConstraintSet* cs1ptr=csm.processNewOrExisting(cs1);
es1=EState(1,pstateptr1,cs1ptr);
ConstraintSet cs2;
cs2.addConstraint(Constraint(Constraint::EQ_VAR_CONST,x,1));
const ConstraintSet* cs2ptr=csm.processNewOrExisting(cs2);
es2=EState(1,pstateptr1,cs2ptr);
ConstraintSet cs3;
cs3.addConstraint(Constraint(Constraint::NEQ_VAR_CONST,x,1));
const ConstraintSet* cs3ptr=csm.processNewOrExisting(cs3);
es3=EState(3,pstateptr4,cs3ptr);
check("check es1 does not exist in eStateSet",eStateSet.exists(es1)==0);
check("check es2 does not exist in eStateSet",eStateSet.exists(es2)==0);
check("check es3 does not exist in eStateSet",eStateSet.exists(es3)==0);
check("es1!=es2",es1!=es2);
check("es2!=es3",es1!=es3);
check("es1!=es3",es2!=es3);
#ifdef ESTATE_MAINTAINER_LIST
nocheck("es1<es2",es2<es1);
nocheck("!(es2<es1)",!(es1<es2));
#endif
#ifdef ESTATE_MAINTAINER_SET
check("es1<es2",es1<es2);
check("!(es2<es1)",!(es2<es1));
#endif
check("!(es1==es2)",!(es1==es2));
#ifdef ESTATE_MAINTAINER_LIST
nocheck("es1<es3",es1<es3);
nocheck("es2<es3",es2<es3);
#endif
#ifdef ESTATE_MAINTAINER_SET
check("es1<es3",es1<es3);
check("es2<es3",es2<es3);
#endif
check("es2==es2",es2==es2);
check("=> eStateSet.size() == 0",eStateSet.size() == 0);
check("es1 does not exist in eStateSet",!eStateSet.exists(es2));
eStateSet.processNewOrExisting(es1);
const EState* estateptr1=eStateSet.processNewOrExisting(es1);
check("add es1 and obtain pointer to es1 from eStateSet and check !=0",estateptr1!=0);
check("es1 exists in eStateSet",eStateSet.exists(es1));
check("=> eStateSet.size() == 1",eStateSet.size() == 1);
check("es2 does not exist in eStateSet",!eStateSet.exists(es2));
eStateSet.processNewOrExisting(es2);
const EState* estateptr2=eStateSet.processNewOrExisting(es2);
check("add es2 and obtain pointer to es2 from eStateSet and check !=0",estateptr2!=0);
check("es2 exists in eStateSet",eStateSet.exists(es2));
check("=> eStateSet.size() == 2",eStateSet.size() == 2);
check("es3 does not exist in eStateSet",!eStateSet.exists(es3));
eStateSet.processNewOrExisting(es3);
const EState* estateptr3=eStateSet.processNewOrExisting(es3);
check("add es3 and obtain pointer to es3 from eStateSet and check !=0",estateptr3!=0);
check("es3 exists in eStateSet",eStateSet.exists(es3));
check("=> eStateSet.size() == 3",eStateSet.size() == 3);
checkLargeSets();
#endif
}
#if 0
// MS: TODO: rewrite the following test to new check format
{
cout << "------------------------------------------"<<endl;
cout << "RUNNING CHECKS FOR COMBINED TYPES:"<<endl;
EState es1;
EState es2;
cout << "EState created. "<<endl;
cout << "empty EState: "<<es1.toString()<<endl;
es1.setLabel(1);
VariableId var_x=variableIdMapping.createUniqueTemporaryVariableId("x");
es1.constraints.addConstraint(Constraint(Constraint::EQ_VAR_CONST,var_x,1));
es2.setLabel(1);
es2.constraints.addConstraint(Constraint(Constraint::NEQ_VAR_CONST,var_x,1));
cout << "empty EState with label and constraint es1: "<<es1.toString()<<endl;
cout << "empty EState with label and constraint es2: "<<es2.toString()<<endl;
PState s;
es1.setPState(&s);
es2.setPState(&s);
cout << "empty EState with label, empty pstate, and constraint es1: "<<es1.toString()<<endl;
cout << "empty EState with label, empty pstate, and constraint es2: "<<es2.toString()<<endl;
bool testres=(es1==es2);
if(testres)
cout << "es1==es2: "<<testres<< "(not as expected: FAIL)"<<endl;
else
cout << "es1==es2: "<<testres<< "(as expected: PASS)"<<endl;
}
#endif
// check stream operators
{
cout << "------------------------------------------"<<endl;
cout << "RUNNING CHECKS FOR INPUT/OUTPUT STREAM OPs"<<endl;
stringstream ss2;
ss2<<"test1";
check("Parse: Testing test2 on test1.",!SPRAY::Parse::checkWord("test2",ss2));
//cout << "Remaing stream: "<<ss2.str()<<endl;
stringstream ss3;
ss3<<"test1";
check("Parse: Testing test1 on test1.",SPRAY::Parse::checkWord("test1",ss3));
//cout << "Remaing stream: "<<ss3.str()<<endl;
CodeThorn::AType::ConstIntLattice x;
stringstream ss4;
ss4<<"top";
x.fromStream(ss4);
check("ConstIntLattice: streaminput: top",x.toString()=="top");
stringstream ss5;
ss5<<"12";
x.fromStream(ss5);
check("ConstIntLattice: streaminput: 12",x.toString()=="12");
stringstream ss6;
ss6<<"15top16";
ss6>>x;
check("ConstIntLattice: streaminput: 15",x.toString()=="15");
ss6>>x;
check("ConstIntLattice: streaminput: top",x.toString()=="top");
ss6>>x;
check("ConstIntLattice: streaminput: 16",x.toString()=="16");
{
PState ps;
stringstream ss1;
string pstateString="{}";
ss1<<pstateString;
ps.fromStream(ss1);
string checkString=(string("stream input PState: ")+pstateString);
bool checkresult=(ps.toString()==pstateString);
check(checkString,checkresult);
if(checkresult==false) {
cout << "Error: input stream result: "<<ps.toString()<<endl;
}
}
{
PState ps;
stringstream ss0;
string pstateString="{(V0,5),(V1,top),(V2,bot)}";
ss0<<pstateString;
ss0>>ps;
string checkString=(string("stream input PState: ")+pstateString);
bool checkresult=(ps.toString()==pstateString);
check(checkString,checkresult);
if(checkresult==false) {
cout << "pstateString :"<<pstateString<<":"<<endl;
cout << "ps.toString():"<<ps.toString()<<":"<<endl;
}
}
{
stringstream ss;
string s="aaabbb";
ss<<s;
string parseString="aaa";
SPRAY::Parse::parseString(parseString,ss); // throws exception if it fails
char next;
ss>>next;
check(string("Parsing: ")+parseString+" from:"+s+" Next:"+next,true);
}
{
Constraint cs;
stringstream ss;
stringstream ssout;
string cstring="V1==V2";
ss<<cstring;
cs.fromStream(ss);
cs.toStream(ssout);
check("Stream I/O constraint: "+cstring,ssout.str()==cstring);
}
{
Constraint cs;
stringstream ss;
stringstream ssout;
string cstring="V3!=4";
ss<<cstring;
cs.fromStream(ss);
cs.toStream(ssout);
check("Stream I/O constraint: "+cstring,ssout.str()==cstring);
}
{
Constraint cs;
cs=DISEQUALITYCONSTRAINT;
stringstream ss;
stringstream ssout;
string cstring=cs.toString();
ss<<cstring;
cs.fromStream(ss);
cs.toStream(ssout);
check("Stream I/O DEQ constraint: "+cstring,ssout.str()==cstring);
}
#ifndef EXCLUDE_RDANALYSIS
{
RDLattice a;
VariableId var1;
var1.setIdCode(1);
VariableId var2;
var2.setIdCode(2);
a.insertPair(1,var1);
RDLattice b;
b.insertPair(1,var1);
b.insertPair(2,var2);
//a.toStream(cout);cout<<endl;
//b.toStream(cout);cout<<endl;
check("a ApproximatedBy b",a.approximatedBy(b)==true);
check("not (b ApproximatedBy a)",b.approximatedBy(a)==false);
}
#endif
} // end of stream operator checks
}
/*
* Adds the given Contraint to the appropriate ConstraintSet.
*/
void
MultiValidatorConstraints::add (VConstraint* c)
{
if (c == NULL) return;
ptrMap.insert(pair<VConstraint*,bool>(c,true));
if (dynamic_cast< TConstraint<SBMLDocument>* >(c) != NULL)
{
mSBMLDocument.add( static_cast< TConstraint<SBMLDocument>* >(c) );
return;
}
if (dynamic_cast< TConstraint<Model>* >(c) != NULL)
{
mModel.add( static_cast< TConstraint<Model>* >(c) );
return;
}
if (dynamic_cast< TConstraint<PossibleSpeciesFeatureValue>* >(c) != NULL)
{
mPossibleSpeciesFeatureValue.add( static_cast< TConstraint<PossibleSpeciesFeatureValue>* >(c) );
return;
}
if (dynamic_cast< TConstraint<SpeciesFeatureValue>* >(c) != NULL)
{
mSpeciesFeatureValue.add( static_cast< TConstraint<SpeciesFeatureValue>* >(c) );
return;
}
if (dynamic_cast< TConstraint<CompartmentReference>* >(c) != NULL)
{
mCompartmentReference.add( static_cast< TConstraint<CompartmentReference>* >(c) );
return;
}
if (dynamic_cast< TConstraint<SpeciesTypeInstance>* >(c) != NULL)
{
mSpeciesTypeInstance.add( static_cast< TConstraint<SpeciesTypeInstance>* >(c) );
return;
}
if (dynamic_cast< TConstraint<InSpeciesTypeBond>* >(c) != NULL)
{
mInSpeciesTypeBond.add( static_cast< TConstraint<InSpeciesTypeBond>* >(c) );
return;
}
if (dynamic_cast< TConstraint<DenotedSpeciesTypeComponentIndex>* >(c) != NULL)
{
mDenotedSpeciesTypeComponentIndex.add( static_cast< TConstraint<DenotedSpeciesTypeComponentIndex>* >(c) );
return;
}
if (dynamic_cast< TConstraint<OutwardBindingSite>* >(c) != NULL)
{
mOutwardBindingSite.add( static_cast< TConstraint<OutwardBindingSite>* >(c) );
return;
}
if (dynamic_cast< TConstraint<SpeciesFeatureChange>* >(c) != NULL)
{
mSpeciesFeatureChange.add( static_cast< TConstraint<SpeciesFeatureChange>* >(c) );
return;
}
if (dynamic_cast< TConstraint<SpeciesFeatureType>* >(c) != NULL)
{
mSpeciesFeatureType.add( static_cast< TConstraint<SpeciesFeatureType>* >(c) );
return;
}
if (dynamic_cast< TConstraint<SpeciesTypeComponentIndex>* >(c) != NULL)
{
mSpeciesTypeComponentIndex.add( static_cast< TConstraint<SpeciesTypeComponentIndex>* >(c) );
return;
}
if (dynamic_cast< TConstraint<SpeciesFeature>* >(c) != NULL)
{
mSpeciesFeature.add( static_cast< TConstraint<SpeciesFeature>* >(c) );
return;
}
if (dynamic_cast< TConstraint<SpeciesTypeComponentMapInProduct>* >(c) != NULL)
{
mSpeciesTypeComponentMapInProduct.add( static_cast< TConstraint<SpeciesTypeComponentMapInProduct>* >(c) );
return;
}
if (dynamic_cast< TConstraint<MultiSpeciesType>* >(c) != NULL)
{
mMultiSpeciesType.add( static_cast< TConstraint<MultiSpeciesType>* >(c) );
return;
}
}
