/// create conjunction of given formulas
DLTree* createSNFAnd ( DLTree* C, DLTree* D )
{
// try to simplify conjunction
if ( C == NULL ) // single element
return D;
if ( D == NULL )
return C;
if ( C->Element() == TOP || // T\and D = D
D->Element() == BOTTOM ) // C\and F = F
{
deleteTree(C);
return D;
}
if ( D->Element() == TOP || // C\and T = C
C->Element() == BOTTOM ) // F\and D = F
{
deleteTree(D);
return C;
}
// no simplification possible -- return actual conjunction
return new DLTree ( TLexeme(AND), C, D );
}
/*
* Class: uk_ac_manchester_cs_factplusplus_FaCTPlusPlus
* Method: askRelatedValues
* Signature: (Luk/ac/manchester/cs/factplusplus/IndividualPointer;Luk/ac/manchester/cs/factplusplus/DataPropertyPointer;)[Luk/ac/manchester/cs/factplusplus/DataValuePointer;
*/
JNIEXPORT jobjectArray JNICALL Java_uk_ac_manchester_cs_factplusplus_FaCTPlusPlus_askRelatedValues
(JNIEnv * env, jobject obj ATTR_UNUSED, jobject arg1 ATTR_UNUSED, jobject arg2 ATTR_UNUSED)
{
TRACE_JNI("askRelatedValues");
TRACE_ARG(env,obj,arg1);
TRACE_ARG(env,obj,arg2);
Throw ( env, "FaCT++ Kernel: unsupported operation 'askRelatedValues'" );
return nullptr;
#if 0
ReasoningKernel::NamesVector Js;
PROCESS_SIMPLE_QUERY ( J->K->getRoleFillers ( getROIndividualExpr(env,arg1), getRODRoleExpr(env,arg2), Js ) );
std::vector<TExpr*> acc;
for ( ReasoningKernel::NamesVector::const_iterator p = Js.begin(), p_end = Js.end(); p < p_end; ++p )
acc.push_back(new TExpr(TLexeme(DATAEXPR,const_cast<TNamedEntry*>(*p))));
return J->buildArray ( acc, J->DataValuePointer );
#endif
}
/// create inverse of role R
DLTree* createInverse ( DLTree* R )
{
fpp_assert ( R != NULL ); // sanity check
switch ( R->Element().getToken() )
{
case INV: // R-- = R
{
DLTree* p = clone(R->Left());
deleteTree(R);
return p;
}
case RNAME: // object role name
if ( unlikely(isTopRole(R)) || unlikely(isBotRole(R)) )
return R; // top/bottom roles are inverses of themselves
return new DLTree ( TLexeme(INV), R );
default: // no other elements can have inverses
fpp_unreachable();
}
}
/// create negation of given formula
DLTree* createSNFNot ( DLTree* C )
{
fpp_assert ( C != NULL ); // sanity check
if ( C->Element() == BOTTOM )
{ // \not F = T
deleteTree(C);
return createTop();
}
if ( C->Element() == TOP )
{ // \not T = F
deleteTree(C);
return createBottom();
}
if ( C->Element () == NOT )
{ // \not\not C = C
DLTree* p = clone(C->Left());
deleteTree(C);
return p;
}
// general case
return new DLTree ( TLexeme(NOT), C );
}
void TBox :: buildDAG ( void )
{
nNominalReferences = 0;
// init concept indexing
nC = 1; // start with 1 to make index 0 an indicator of "not processed"
ConceptMap.push_back(NULL);
// make fresh concept and datatype
concept2dag(pTemp);
DLTree* freshDT = DTCenter.getFreshDataType();
addDataExprToHeap ( static_cast<TDataEntry*>(freshDT->Element().getNE()) );
deleteTree(freshDT);
for ( c_const_iterator pc = c_begin(); pc != c_end(); ++pc )
concept2dag(*pc);
for ( i_const_iterator pi = i_begin(); pi != i_end(); ++pi )
concept2dag(*pi);
// init heads of simple rules
for ( TSimpleRules::iterator q = SimpleRules.begin(), q_end = SimpleRules.end(); q < q_end; ++q )
(*q)->bpHead = tree2dag((*q)->tHead);
// builds Roles range and domain
initRangeDomain(ORM);
initRangeDomain(DRM);
// build all splits
for ( TSplitVars::iterator s = getSplits()->begin(), s_end = getSplits()->end(); s != s_end; ++s )
split2dag(*s);
RoleMaster::iterator p, p_end;
// build all GCIs
DLTree* GCI = Axioms.getGCI();
// add special domains to the GCIs
if ( likely(useSpecialDomains) )
for ( p = ORM.begin(), p_end = ORM.end(); p < p_end; ++p )
if ( !(*p)->isSynonym() && (*p)->hasSpecialDomain() )
GCI = createSNFAnd ( GCI, clone((*p)->getTSpecialDomain()) );
// take chains that lead to Bot role into account
if ( !ORM.getBotRole()->isSimple() )
GCI = createSNFAnd ( GCI,
new DLTree ( TLexeme(FORALL), createRole(ORM.getBotRole()), createBottom() ) );
T_G = tree2dag(GCI);
deleteTree(GCI);
// mark GCI flags
GCIs.setGCI(T_G != bpTOP);
GCIs.setReflexive(ORM.hasReflexiveRoles());
// builds functional labels for roles
for ( p = ORM.begin(), p_end = ORM.end(); p < p_end; ++p )
if ( !(*p)->isSynonym() && (*p)->isTopFunc() )
(*p)->setFunctional ( atmost2dag ( 1, *p, bpTOP ) );
for ( p = DRM.begin(), p_end = DRM.end(); p < p_end; ++p )
if ( !(*p)->isSynonym() && (*p)->isTopFunc() )
(*p)->setFunctional ( atmost2dag ( 1, *p, bpTOP ) );
// check the type of the ontology
if ( nNominalReferences > 0 )
{
unsigned int nInd = i_end() - i_begin();
if ( nInd > 100 && nNominalReferences > nInd )
isLikeWINE = true;
}
// here DAG is complete; set its final size
DLHeap.setFinalSize();
}
