|
Alignment API and Server 3.2 | |||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl |
---|
Methods in fr.inrialpes.exmo.align.impl that throw AlignmentException | |
---|---|
void |
BasicAlignment.accept(AlignmentVisitor visitor)
|
void |
BasicCell.accept(AlignmentVisitor visitor)
|
void |
BasicRelation.accept(AlignmentVisitor visitor)
|
void |
OWLAPICell.accept(AlignmentVisitor visitor)
|
void |
URICell.accept(AlignmentVisitor visitor)
|
Cell |
BasicAlignment.addAlignCell(Object ob1,
Object ob2)
|
Cell |
OWLAPIAlignment.addAlignCell(Object ob1,
Object ob2)
|
Cell |
URIAlignment.addAlignCell(Object ob1,
Object ob2)
|
Cell |
BasicAlignment.addAlignCell(Object ob1,
Object ob2,
String relation,
double measure)
|
Cell |
OWLAPIAlignment.addAlignCell(Object ob1,
Object ob2,
String relation,
double measure)
|
Cell |
URIAlignment.addAlignCell(Object ob1,
Object ob2,
String relation,
double measure)
|
Cell |
BasicAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
Cell |
OWLAPIAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
Cell |
URIAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
Cell methods |
Cell |
BasicAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure,
Parameters extensions)
Cell methods |
Cell |
OWLAPIAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure,
Parameters extensions)
Cell methods |
void |
DistanceAlignment.addAlignDistanceCell(Object ob1,
Object ob2,
String relation,
double measure)
|
protected void |
BasicAlignment.addCell(Cell c)
|
void |
DistanceAlignment.align(Alignment alignment,
Parameters params)
Process matching - create distance data structures, - compute distance or similarity - extract alignment |
Alignment |
BasicAlignment.compose(Alignment align)
The second alignment is composed with the first one meaning that for any pair (o, o', n, r) in O and (o',o", n', r') in O' the resulting alignment will contain: ( o, o", join(n,n'), compose(r, r')) iff compose(r,r') exists. |
Cell |
BasicCell.compose(Cell c)
|
Cell |
BasicAlignment.createCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
Cell |
OWLAPIAlignment.createCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
Cell |
URIAlignment.createCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
void |
BasicAlignment.cut(double threshold)
Default cut implementation For compatibility with API until version 1.1 |
void |
BasicAlignment.cut(String method,
double threshold)
Cut refinement : - getting those cells with strength above n (hard) - getting the n best cells (best) - getting those cells with strength at worse n under the best (span) - getting the n% best cells (perc) - getting those cells with strength at worse n% of the best (prop) Rule: threshold is betweew 1 and 0 |
void |
BasicAlignment.cut2(double threshold)
The cut function suppresses from an alignment all the cell over a particulat threshold |
Alignment |
DistanceAlignment.extract(String type,
Parameters params)
Extract the alignment form the Similarity There are theoretically 16 types of extractors composing the characteristics [q]estion mark = ?, one or zero relation [s]tar = *, one, zero or many relations [1] = 1, exactly one relation [p]lus = +, one or many relations for each place of the relation. |
Cell |
BasicAlignment.getAlignCell1(Object ob)
|
Cell |
OWLAPIAlignment.getAlignCell1(Object ob)
|
Cell |
URIAlignment.getAlignCell1(Object ob)
|
Cell |
BasicAlignment.getAlignCell2(Object ob)
|
Cell |
OWLAPIAlignment.getAlignCell2(Object ob)
|
Cell |
URIAlignment.getAlignCell2(Object ob)
|
Set |
BasicAlignment.getAlignCells1(Object ob)
|
Set |
OWLAPIAlignment.getAlignCells1(Object ob)
|
Set |
URIAlignment.getAlignCells1(Object ob)
|
Set |
BasicAlignment.getAlignCells2(Object ob)
|
Set |
OWLAPIAlignment.getAlignCells2(Object ob)
|
Set |
URIAlignment.getAlignCells2(Object ob)
|
double |
DistanceAlignment.getAlignedDistance1(Object ob)
|
double |
DistanceAlignment.getAlignedDistance2(Object ob)
|
Object |
BasicAlignment.getAlignedObject1(Object ob)
|
Object |
BasicAlignment.getAlignedObject2(Object ob)
|
Relation |
BasicAlignment.getAlignedRelation1(Object ob)
|
Relation |
BasicAlignment.getAlignedRelation2(Object ob)
|
double |
BasicAlignment.getAlignedStrength1(Object ob)
|
double |
BasicAlignment.getAlignedStrength2(Object ob)
|
URI |
BasicCell.getObject1AsURI()
|
URI |
OWLAPICell.getObject1AsURI()
|
URI |
URICell.getObject1AsURI()
|
URI |
BasicCell.getObject2AsURI()
|
URI |
OWLAPICell.getObject2AsURI()
|
URI |
URICell.getObject2AsURI()
|
URI |
BasicAlignment.getOntology1URI()
|
URI |
BasicAlignment.getOntology2URI()
|
void |
BasicAlignment.harden(double threshold)
The harden function acts like threshold but put all weights to 1. |
void |
BasicAlignment.ingest(Alignment alignment)
Incorporate the cells of the alignment into its own alignment. |
void |
BasicAlignment.init(Object onto1,
Object onto2)
|
void |
OWLAPIAlignment.init(Object onto1,
Object onto2)
|
void |
URIAlignment.init(Object o1,
Object o2)
|
void |
BasicAlignment.init(Object onto1,
Object onto2,
Object cache)
|
void |
OWLAPIAlignment.init(Object o1,
Object o2,
Object ontologies)
|
Alignment |
BasicAlignment.inverse()
A new alignment is created such that for any pair (o, o', n, r) in O the resulting alignment will contain: ( o', o, n, inverse(r)) iff compose(r) exists. |
Cell |
BasicCell.inverse()
|
Cell |
OWLAPICell.inverse()
|
Cell |
URICell.inverse()
|
Alignment |
BasicAlignment.join(Alignment align)
The second alignment is join with the first one meaning that for any pair (o, o', n, r) in O and (o, o', n', r) in O' the resulting alignment will contain: ( o, o", join(n,n'), r) any pair which is in only one alignment is discarded. |
void |
OWLAPIAlignment.loadInit(Alignment al)
|
void |
OWLAPIAlignment.loadInit(Alignment al,
OntologyCache ontologies)
|
Alignment |
BasicAlignment.meet(Alignment align)
The second alignment is meet with the first one meaning that for any pair (o, o', n, r) in O and (o, o', n', r) in O' the resulting alignment will contain: ( o, o', meet(n,n'), r) any pair which is in only one alignment is preserved. |
void |
BasicAlignment.removeAlignCell(Cell c)
|
void |
BasicAlignment.render(AlignmentVisitor renderer)
This should be rewritten in order to generate the axiom ontology instead of printing it! And then use ontology serialization for getting it printed. |
void |
BasicCell.setObject1(Object ob)
|
void |
BasicCell.setObject2(Object ob)
|
void |
BasicAlignment.setOntology1(Object ontology)
|
void |
URIAlignment.setOntology1(Object ontology)
|
void |
BasicAlignment.setOntology2(Object ontology)
|
void |
URIAlignment.setOntology2(Object ontology)
|
static OWLAPIAlignment |
OWLAPIAlignment.toOWLAPIAlignment(URIAlignment al,
OntologyCache ontologies)
|
URIAlignment |
BasicAlignment.toURIAlignment()
Returns default exception for conversion to URIAlignments |
URIAlignment |
OWLAPIAlignment.toURIAlignment()
This is a clone with the URI instead of OWLAPI objects |
URIAlignment |
URIAlignment.toURIAlignment()
Returns default exception for conversion to URIAlignments |
Constructors in fr.inrialpes.exmo.align.impl that throw AlignmentException | |
---|---|
BasicCell(String id,
Object ob1,
Object ob2,
Relation rel,
double m)
Creation |
|
OWLAPICell(String id,
org.semanticweb.owl.model.OWLEntity ob1,
org.semanticweb.owl.model.OWLEntity ob2,
Relation rel,
double m)
Creation |
|
URICell(String id,
URI ob1,
URI ob2,
Relation rel,
double m)
Creation |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.eval |
---|
Methods in fr.inrialpes.exmo.align.impl.eval that throw AlignmentException | |
---|---|
double |
ExtPREvaluator.eval(Parameters params)
This is a partial implementation of [Ehrig & Euzenat 2005] because the relations are not taken into account (they are supposed to be always =) |
double |
PRGraphEvaluator.eval(Parameters params)
Compute precision and recall graphs. |
double |
PRecEvaluator.eval(Parameters params)
The formulas are standard: given a reference alignment A given an obtained alignment B which are sets of cells (linking one entity of ontology O to another of ontolohy O'). |
double |
SymMeanEvaluator.eval(Parameters params)
|
double |
ExtPREvaluator.eval(Parameters params,
Object cache)
|
double |
PRGraphEvaluator.eval(Parameters params,
Object cache)
|
double |
PRecEvaluator.eval(Parameters params,
Object cache)
|
double |
SymMeanEvaluator.eval(Parameters params,
Object cache)
|
Constructors in fr.inrialpes.exmo.align.impl.eval that throw AlignmentException | |
---|---|
PRecEvaluator(Alignment align1,
Alignment align2)
Creation |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.method |
---|
Methods in fr.inrialpes.exmo.align.impl.method that throw AlignmentException | |
---|---|
void |
ClassStructAlignment.align(Alignment alignment,
Parameters params)
Processing |
void |
NameAndPropertyAlignment.align(Alignment alignment,
Parameters params)
Processing |
void |
NameEqAlignment.align(Alignment alignment,
Parameters params)
Processing |
void |
StringDistAlignment.align(Alignment alignment,
Parameters params)
|
void |
StrucSubsDistAlignment.align(Alignment alignment,
Parameters params)
Processing |
void |
SubsDistNameAlignment.align(Alignment alignment,
Parameters params)
Processing |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.rel |
---|
Methods in fr.inrialpes.exmo.align.impl.rel that throw AlignmentException | |
---|---|
void |
EquivRelation.accept(AlignmentVisitor visitor)
|
void |
IncompatRelation.accept(AlignmentVisitor visitor)
|
void |
NonTransitiveImplicationRelation.accept(AlignmentVisitor visitor)
|
void |
SubsumeRelation.accept(AlignmentVisitor visitor)
|
void |
SubsumedRelation.accept(AlignmentVisitor visitor)
|
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.renderer |
---|
Methods in fr.inrialpes.exmo.align.impl.renderer that throw AlignmentException | |
---|---|
private void |
XSLTRendererVisitor.collectURIs(Cell cell)
|
void |
COWLMappingRendererVisitor.visit(Alignment align)
|
void |
HTMLRendererVisitor.visit(Alignment align)
|
void |
OWLAxiomsRendererVisitor.visit(Alignment align)
|
void |
RDFRendererVisitor.visit(Alignment align)
|
void |
SEKTMappingRendererVisitor.visit(Alignment align)
|
void |
SKOSRendererVisitor.visit(Alignment align)
|
void |
SWRLRendererVisitor.visit(Alignment align)
|
void |
XMLMetadataRendererVisitor.visit(Alignment align)
|
void |
XSLTRendererVisitor.visit(Alignment align)
|
void |
COWLMappingRendererVisitor.visit(Cell cell)
|
void |
HTMLRendererVisitor.visit(Cell cell)
|
void |
OWLAxiomsRendererVisitor.visit(Cell cell)
|
void |
RDFRendererVisitor.visit(Cell cell)
|
void |
SEKTMappingRendererVisitor.visit(Cell cell)
|
void |
SKOSRendererVisitor.visit(Cell cell)
|
void |
SWRLRendererVisitor.visit(Cell cell)
|
void |
XSLTRendererVisitor.visit(Cell cell)
|
void |
COWLMappingRendererVisitor.visit(EquivRelation rel)
|
void |
OWLAxiomsRendererVisitor.visit(EquivRelation rel)
|
void |
SEKTMappingRendererVisitor.visit(EquivRelation rel)
|
void |
SKOSRendererVisitor.visit(EquivRelation rel)
|
void |
SWRLRendererVisitor.visit(EquivRelation rel)
|
void |
XSLTRendererVisitor.visit(EquivRelation rel)
|
void |
COWLMappingRendererVisitor.visit(IncompatRelation rel)
|
void |
OWLAxiomsRendererVisitor.visit(IncompatRelation rel)
|
void |
SEKTMappingRendererVisitor.visit(IncompatRelation rel)
|
void |
SKOSRendererVisitor.visit(IncompatRelation rel)
|
void |
COWLMappingRendererVisitor.visit(Relation rel)
|
void |
OWLAxiomsRendererVisitor.visit(Relation rel)
|
void |
SEKTMappingRendererVisitor.visit(Relation rel)
|
void |
SKOSRendererVisitor.visit(Relation rel)
|
void |
SWRLRendererVisitor.visit(Relation rel)
|
void |
XSLTRendererVisitor.visit(Relation rel)
|
void |
COWLMappingRendererVisitor.visit(SubsumedRelation rel)
|
void |
OWLAxiomsRendererVisitor.visit(SubsumedRelation rel)
|
void |
SEKTMappingRendererVisitor.visit(SubsumedRelation rel)
|
void |
SKOSRendererVisitor.visit(SubsumedRelation rel)
|
void |
COWLMappingRendererVisitor.visit(SubsumeRelation rel)
|
void |
OWLAxiomsRendererVisitor.visit(SubsumeRelation rel)
|
void |
SEKTMappingRendererVisitor.visit(SubsumeRelation rel)
|
void |
SKOSRendererVisitor.visit(SubsumeRelation rel)
|
Uses of AlignmentException in fr.inrialpes.exmo.align.ling |
---|
Methods in fr.inrialpes.exmo.align.ling that throw AlignmentException | |
---|---|
void |
JWNLAlignment.align(Alignment alignment,
Parameters params)
Processing |
void |
JWNLAlignment.SynonymMatrixMeasure.init()
|
void |
JWNLAlignment.SynonymMatrixMeasure.init(String wndict)
|
void |
JWNLAlignment.SynonymMatrixMeasure.init(String wndict,
String wnvers)
|
void |
JWNLDistances.Initialize()
Initialize the JWNL API. |
void |
JWNLDistances.Initialize(String wordnetdir,
String wordnetversion)
|
Uses of AlignmentException in fr.inrialpes.exmo.align.service |
---|
Methods in fr.inrialpes.exmo.align.service that throw AlignmentException | |
---|---|
void |
AServProtocolManager.init(DBService connection,
Parameters p)
|
void |
CacheImpl.init(Parameters p)
loads the alignment descriptions from the database and put them in the alignmentTable hashtable |
String |
CacheImpl.recordNewAlignment(String id,
Alignment al,
boolean force)
records alignment identified by id |
void |
CacheImpl.resetDatabase(boolean force)
|
protected Alignment |
CacheImpl.retrieveAlignment(String id,
Alignment alignment)
loads the full alignments from the database and put them in the alignmentTable hastable should be invoked when: ( result.getExtension(CACHED) == "" && result.getExtension(STORED) != "") { |
String |
QueryMediator.rewriteQuery(String aQuery)
|
static String |
QueryMediator.rewriteSPARQLQuery(String aQuery,
Alignment align)
|
void |
CacheImpl.updateDatabase()
|
Uses of AlignmentException in fr.inrialpes.exmo.align.util |
---|
Methods in fr.inrialpes.exmo.align.util that throw AlignmentException | |
---|---|
Evaluator |
GroupOutput.eval(String alignName1,
String alignName2)
|
Uses of AlignmentException in org.semanticweb.owl.align |
---|
Methods in org.semanticweb.owl.align that throw AlignmentException | |
---|---|
void |
Alignment.accept(AlignmentVisitor visitor)
Alignment methods |
void |
Cell.accept(AlignmentVisitor visitor)
|
void |
Relation.accept(AlignmentVisitor visitor)
Creation |
Cell |
Alignment.addAlignCell(Object ob1,
Object ob2)
|
Cell |
Alignment.addAlignCell(Object ob1,
Object ob,
String relation,
double measure)
Cells are created and indexed at once |
void |
AlignmentProcess.align(Alignment alignment,
Parameters param)
The align method computes the alignment from the ontologies. |
Alignment |
Alignment.compose(Alignment align)
|
Cell |
Cell.compose(Cell c)
|
void |
Alignment.cut(double threshold)
|
void |
Alignment.cut(String method,
double threshold)
|
double |
Evaluator.eval(Parameters param)
Run the evaluation between the two ontologies. |
double |
Evaluator.eval(Parameters param,
Object cache)
Run the evaluation between the two ontologies. |
Cell |
Alignment.getAlignCell1(Object ob)
Cells are retrieved These primitives are deprecated. |
Cell |
Alignment.getAlignCell2(Object ob)
|
Set |
Alignment.getAlignCells1(Object ob)
Cells are retrieved These primitives are deprecated. |
Set |
Alignment.getAlignCells2(Object ob)
|
Object |
Alignment.getAlignedObject1(Object ob)
Each part of the cell can be queried independently. |
Object |
Alignment.getAlignedObject2(Object ob)
|
Relation |
Alignment.getAlignedRelation1(Object ob)
|
Relation |
Alignment.getAlignedRelation2(Object ob)
|
double |
Alignment.getAlignedStrength1(Object ob)
|
double |
Alignment.getAlignedStrength2(Object ob)
|
URI |
Cell.getObject1AsURI()
|
URI |
Cell.getObject2AsURI()
|
URI |
Alignment.getOntology1URI()
|
URI |
Alignment.getOntology2URI()
|
void |
Alignment.harden(double threshold)
|
void |
Alignment.init(Object onto1,
Object onto2)
Initialize the alignement before using it |
void |
Alignment.init(Object onto1,
Object onto2,
Object cache)
Initialize the alignement before using it, with some ontology caching trick |
Alignment |
Alignment.inverse()
Algebra of alignment manipulation operations: compose, join, meet. |
Cell |
Cell.inverse()
|
Alignment |
Alignment.join(Alignment align)
|
Alignment |
Alignment.meet(Alignment align)
|
void |
Alignment.render(AlignmentVisitor renderer)
Exporting The alignments are exported for other purposes. |
void |
Cell.setObject1(Object ob)
|
void |
Cell.setObject2(Object ob)
|
void |
Alignment.setOntology1(Object ontology)
|
void |
Alignment.setOntology2(Object ontology)
|
void |
AlignmentVisitor.visit(Alignment a)
|
void |
AlignmentVisitor.visit(Cell c)
|
void |
AlignmentVisitor.visit(Relation r)
|
|
Alignment API and Server 3.2 | |||||||||
PREV NEXT | FRAMES NO FRAMES |