Tree-M/MT/MTpredicate.h

/*********************************************************************
*                                                                    *
* Copyright (c) 1997,1998, 1999                                      *
* Multimedia DB Group and DEIS - CSITE-CNR,                          *
* University of Bologna, Bologna, ITALY.                             *
*                                                                    *
* All Rights Reserved.                                               *
*                                                                    *
* Permission to use, copy, and distribute this software and its      *
* documentation for NON-COMMERCIAL purposes and without fee is       *
* hereby granted provided  that this copyright notice appears in     *
* all copies.                                                        *
*                                                                    *
* THE AUTHORS MAKE NO REPRESENTATIONS OR WARRANTIES ABOUT THE        *
* SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING  *
* BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY,      *
* FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. THE AUTHOR  *
* SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A      *
* RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS    *
* DERIVATIVES.                                                       *
*                                                                    *
*********************************************************************/

#ifndef MTPREDICATE_H
#define MTPREDICATE_H

#include "MTobject.h"

//class GiSTentry;

typedef enum {
        FUZZY_STANDARD,
        FUZZY_ALGEBRAIC
} language;

typedef enum {
        LINEAR,
        EXPONENTIAL,
        DISTR
} dist2sim;

extern language query_language;

double Dist2Sim(double dist);
double Sim2Dist(double sim);

class MTpred: public GiSTobject {       // the base class for predicates
public:
        virtual GiSTobjid IsA() { return MTPREDICATE_CLASS; }
        virtual double distance(const Object &obj) const=0;
        virtual ~MTpred() {}

#ifdef PRINTING_OBJECTS
        virtual void Print(ostream& os) const=0;
#endif
};

class Pred: public MTpred {     // a simple predicate
public:
        // constructors, destructors, etc.
        Pred(const Object &obj): object(obj) {}
        Pred(const Pred& p) : object(p.object) {}
        GiSTobject *Copy() const { return new Pred(*this); }

        // virtual methods
        GiSTobjid IsA() { return MTPREDICATE_CLASS; }
        double distance(const Object &obj) const { 
                return object.distance(obj);
        }

        // access to private methods
        Object obj() const { return object; }

#ifdef PRINTING_OBJECTS
        void Print(ostream& os) const {
                os << object;
        }
#endif

private:
        Object object;
};

class AndPred: public MTpred {  // a conjunction of two predicates
public:
        // constructors, destructors, etc.
        AndPred(const MTpred *p1, const MTpred *p2): pred1((MTpred *)p1->Copy()), pred2((MTpred *)p2->Copy()) {}
        GiSTobject *Copy() const {
                return new AndPred(pred1, pred2);
        }
        ~AndPred() {
                delete pred1;
                delete pred2;
        }

        // virtual methods
        GiSTobjid IsA() { return MTPREDICATE_AND_CLASS; }
        double distance(const Object &obj) const {
                switch(query_language) {
                        case FUZZY_STANDARD: {
                                double s1=Dist2Sim(pred1->distance(obj)), s2=Dist2Sim(pred2->distance(obj));

                                return Sim2Dist(MIN(s1, s2));
                        }
                        case FUZZY_ALGEBRAIC:   return Sim2Dist(Dist2Sim(pred1->distance(obj))*Dist2Sim(pred2->distance(obj)));
                        default:        return maxDist();
                }
        }

        // access to private members
        MTpred *Pred1() const { return pred1; }
        MTpred *Pred2() const { return pred2; }

#ifdef PRINTING_OBJECTS
        void Print(ostream& os) const {
                os << "(" << *pred1 << "&&" << *pred2 << ")";
        }
#endif

private:
        MTpred *pred1, *pred2;
};

class OrPred: public MTpred {   // a disjunction of two predicates
public:
        // constructors, destructors, etc.
        OrPred(const MTpred *p1, const MTpred *p2): pred1((MTpred *)p1->Copy()), pred2((MTpred *)p2->Copy()) {}
        GiSTobject *Copy() const {
                return new OrPred(pred1, pred2);
        }
        ~OrPred() {
                delete pred1;
                delete pred2;
        }

        // virtual methods
        GiSTobjid IsA() { return MTPREDICATE_OR_CLASS; }
        double distance(const Object &obj) const { 
                switch(query_language) {
                        case FUZZY_STANDARD: {
                                double s1=Dist2Sim(pred1->distance(obj)), s2=Dist2Sim(pred2->distance(obj));

                                return Sim2Dist(MAX(s1, s2));
                        }
                        case FUZZY_ALGEBRAIC: {
                                double s1=Dist2Sim(pred1->distance(obj)), s2=Dist2Sim(pred2->distance(obj));

                                return Sim2Dist(s1+s2-s1*s2);
                        }
                        default:        return maxDist();
                }
        }

        // access to private members
        MTpred *Pred1() const { return pred1; }
        MTpred *Pred2() const { return pred2; }

#ifdef PRINTING_OBJECTS
        void Print(ostream& os) const {
                os << "(" << *pred1 << "||" << *pred2 << ")";
        }
#endif

private:
        MTpred *pred1, *pred2;
};

class NotPred: public MTpred {  // a negated predicate
public:
        // constructors, destructors, etc.
        NotPred(const MTpred *p): pred((MTpred *)p->Copy()) {}
        GiSTobject *Copy() const {
                return new NotPred(pred);
        }
        ~NotPred() { delete pred; }

        // virtual methods
        GiSTobjid IsA() { return MTPREDICATE_NOT_CLASS; }
        double distance(const Object &obj) const { 
                return Sim2Dist(1-Dist2Sim(pred->distance(obj)));
        }

        // access to private members
        MTpred *Pred() const { return pred; }

#ifdef PRINTING_OBJECTS
        void Print(ostream& os) const {
                os << "(!" << *pred << ")";
        }
#endif

private:
        MTpred *pred;
};

// for the queries, the conjunction corresponds to intersection, the disjunction to union, and the negation to difference

class MTquery: public GiSTobject {      // the base class for queries
public:
        // constructors, destructors, etc.
        MTquery() : grade(0), isOpen(FALSE) {}
        MTquery(const double g, const BOOL o=FALSE) : grade(g), isOpen(o) {}
        virtual ~MTquery() {}

        // pure virtual methods
        virtual int Consistent(const GiSTentry& entry)=0;
        virtual int NonConsistent(const GiSTentry& entry)=0;

        // access to private members
        double Grade() const { return grade; }
        void SetGrade(double p_grade) { grade=p_grade; }

protected:
        double grade;
        BOOL isOpen;
};

class SimpleQuery : public MTquery {    // a simple query
public:
        // constructors, destructors, etc.
        SimpleQuery(const MTpred *p, const double r, const BOOL o=FALSE) : MTquery(0,o), pred((MTpred *)p->Copy()), radius(r) {}
        SimpleQuery(const SimpleQuery& q) : MTquery(q.grade, q.isOpen), pred((MTpred *)q.pred->Copy()), radius(q.radius) {}
        GiSTobject *Copy() const {
                return new SimpleQuery(*this);
        }
        ~SimpleQuery() { delete pred; }

        // basic consistency methods
        int Consistent(const GiSTentry& entry);
        int NonConsistent(const GiSTentry& entry);

        // access to private members
        double Radius() const { return radius; }
        void SetRadius(double p_radius) { radius=p_radius; }

private:
        MTpred *pred;
        double radius;
};

class AndQuery : public MTquery {       // the conjunction of two queries
public:
        // constructors, destructors, etc.
        AndQuery(const MTquery *q1, const MTquery *q2): q1((MTquery *)q1->Copy()), q2((MTquery *)q2->Copy()) {}
        GiSTobject *Copy() const {
                return new AndQuery(q1, q2);
        }
        ~AndQuery() {
                delete q1;
                delete q2;
        }

        // basic consistency methods
        int Consistent(const GiSTentry& entry) {
                int response=q1->Consistent(entry)&&q2->Consistent(entry);

                grade=MAX(q1->Grade(), q2->Grade());
                return response;
        }
        int NonConsistent(const GiSTentry& entry) {
                int response=q1->NonConsistent(entry)||q2->NonConsistent(entry);

                grade=MAX(q1->Grade(), q2->Grade());    // or what?
                return response;
        }

#ifdef PRINTING_OBJECTS
        void Print(ostream& os) const {
                os << "(" << *q1 << " and " << *q2 << ")";
        }
#endif

private:
        MTquery *q1, *q2;
};

class OrQuery : public MTquery {        // the disjunction of two queries
public:
        // constructors, destructors, etc.
        OrQuery(const MTquery *q1, const MTquery *q2): q1((MTquery *)q1->Copy()), q2((MTquery *)q2->Copy()) {}
        GiSTobject *Copy() const {
                return new OrQuery(q1, q2);
        }
        ~OrQuery() {
                delete q1;
                delete q2;
        }

        // basic consistency methods
        int Consistent(const GiSTentry& entry) {
                int response=q1->Consistent(entry)||q2->Consistent(entry);

                grade=MIN(q1->Grade(), q2->Grade());
                return response;
        }
        int NonConsistent(const GiSTentry& entry) {
                int response=q1->NonConsistent(entry)&&q2->NonConsistent(entry);

                grade=MIN(q1->Grade(), q2->Grade());    // or what?
                return response;
        }

#ifdef PRINTING_OBJECTS
        void Print(ostream& os) const {
                os << "(" << *q1 << " or " << *q2 << ")";
        }
#endif

private:
        MTquery *q1, *q2;
};

class NotQuery: public MTquery {        // the negation of a query
public:
        // constructors, destructors, etc.
        NotQuery(const MTquery *q): q((MTquery *)q->Copy()) {}
        GiSTobject *Copy() const { return new NotQuery(q); }
        ~NotQuery() { delete q; }

        // basic consistency methods
        int Consistent(const GiSTentry& entry) {
                int response=q->NonConsistent(entry);

                grade=q->Grade();
                return response;
        }
        int NonConsistent(const GiSTentry& entry) {
                int response=q->Consistent(entry);

                grade=q->Grade();       // or what?
                return response;
        }

#ifdef PRINTING_OBJECTS
        void Print(ostream& os) const {
                os << "(not " << *q << ")";
        }
#endif

private:
        MTquery *q;
};

class TopQuery: public GiSTobject {     // a simple k-NN query
public:
        // constructors, destructors, etc.
        TopQuery(const MTpred *p, const int n) : k(n), pred((MTpred *)p->Copy()) {}
        TopQuery(const TopQuery& q) : k(q.k), pred((MTpred *)q.pred->Copy()) {}
        GiSTobject *Copy() const { return new TopQuery(*this); }
        ~TopQuery() { delete pred; }

        // access to private members
        const MTpred *Pred() const { return pred; }

        int k;
private:
        MTpred *pred;
};

#endif
Revision:	1.2
Committed:	Fri Jul 27 12:48:23 2001 UTC (25 years, 2 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+2 -2 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	/*********************************************************************
2			* *
3			* Copyright (c) 1997,1998, 1999 *
4			* Multimedia DB Group and DEIS - CSITE-CNR, *
5			* University of Bologna, Bologna, ITALY. *
6			* *
7			* All Rights Reserved. *
8			* *
9			* Permission to use, copy, and distribute this software and its *
10			* documentation for NON-COMMERCIAL purposes and without fee is *
11			* hereby granted provided that this copyright notice appears in *
12			* all copies. *
13			* *
14			* THE AUTHORS MAKE NO REPRESENTATIONS OR WARRANTIES ABOUT THE *
15			* SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING *
16			* BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, *
17			* FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. THE AUTHOR *
18			* SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A *
19			* RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS *
20			* DERIVATIVES. *
21			* *
22			*********************************************************************/
23
24			#ifndef MTPREDICATE_H
25			#define MTPREDICATE_H
26
27			#include "MTobject.h"
28
29			//class GiSTentry;
30
31			typedef enum {
32			FUZZY_STANDARD,
33			FUZZY_ALGEBRAIC
34			} language;
35
36			typedef enum {
37			LINEAR,
38			EXPONENTIAL,
39			DISTR
40			} dist2sim;
41
42			extern language query_language;
43
44			double Dist2Sim(double dist);
45			double Sim2Dist(double sim);
46
47			class MTpred: public GiSTobject { // the base class for predicates
48			public:
49			virtual GiSTobjid IsA() { return MTPREDICATE_CLASS; }
50			virtual double distance(const Object &obj) const=0;
51			virtual ~MTpred() {}
52
53			#ifdef PRINTING_OBJECTS
54			virtual void Print(ostream& os) const=0;
55			#endif
56			};
57
58			class Pred: public MTpred { // a simple predicate
59			public:
60			// constructors, destructors, etc.
61			Pred(const Object &obj): object(obj) {}
62			Pred(const Pred& p) : object(p.object) {}
63			GiSTobject Copy() const { return new Pred(this); }
64
65			// virtual methods
66			GiSTobjid IsA() { return MTPREDICATE_CLASS; }
67			double distance(const Object &obj) const {
68			return object.distance(obj);
69			}
70
71			// access to private methods
72			Object obj() const { return object; }
73
74			#ifdef PRINTING_OBJECTS
75			void Print(ostream& os) const {
76			os << object;
77			}
78			#endif
79
80			private:
81			Object object;
82			};
83
84			class AndPred: public MTpred { // a conjunction of two predicates
85			public:
86			// constructors, destructors, etc.
87			AndPred(const MTpred p1, const MTpred p2): pred1((MTpred )p1->Copy()), pred2((MTpred )p2->Copy()) {}
88			GiSTobject *Copy() const {
89			return new AndPred(pred1, pred2);
90			}
91			~AndPred() {
92			delete pred1;
93			delete pred2;
94			}
95
96			// virtual methods
97			GiSTobjid IsA() { return MTPREDICATE_AND_CLASS; }
98			double distance(const Object &obj) const {
99			switch(query_language) {
100			case FUZZY_STANDARD: {
101			double s1=Dist2Sim(pred1->distance(obj)), s2=Dist2Sim(pred2->distance(obj));
102
103			return Sim2Dist(MIN(s1, s2));
104			}
105			case FUZZY_ALGEBRAIC: return Sim2Dist(Dist2Sim(pred1->distance(obj))*Dist2Sim(pred2->distance(obj)));
106			default: return maxDist();
107			}
108			}
109
110			// access to private members
111			MTpred *Pred1() const { return pred1; }
112			MTpred *Pred2() const { return pred2; }
113
114			#ifdef PRINTING_OBJECTS
115			void Print(ostream& os) const {
116			os << "(" << pred1 << "&&" << pred2 << ")";
117			}
118			#endif
119
120			private:
121			MTpred pred1, pred2;
122			};
123
124			class OrPred: public MTpred { // a disjunction of two predicates
125			public:
126			// constructors, destructors, etc.
127			OrPred(const MTpred p1, const MTpred p2): pred1((MTpred )p1->Copy()), pred2((MTpred )p2->Copy()) {}
128			GiSTobject *Copy() const {
129			return new OrPred(pred1, pred2);
130			}
131			~OrPred() {
132			delete pred1;
133			delete pred2;
134			}
135
136			// virtual methods
137			GiSTobjid IsA() { return MTPREDICATE_OR_CLASS; }
138			double distance(const Object &obj) const {
139			switch(query_language) {
140			case FUZZY_STANDARD: {
141			double s1=Dist2Sim(pred1->distance(obj)), s2=Dist2Sim(pred2->distance(obj));
142
143			return Sim2Dist(MAX(s1, s2));
144			}
145			case FUZZY_ALGEBRAIC: {
146			double s1=Dist2Sim(pred1->distance(obj)), s2=Dist2Sim(pred2->distance(obj));
147
148			return Sim2Dist(s1+s2-s1*s2);
149			}
150			default: return maxDist();
151			}
152			}
153
154			// access to private members
155			MTpred *Pred1() const { return pred1; }
156			MTpred *Pred2() const { return pred2; }
157
158			#ifdef PRINTING_OBJECTS
159			void Print(ostream& os) const {
160			os << "(" << pred1 << "\|\|" << pred2 << ")";
161			}
162			#endif
163
164			private:
165			MTpred pred1, pred2;
166			};
167
168			class NotPred: public MTpred { // a negated predicate
169			public:
170			// constructors, destructors, etc.
171			NotPred(const MTpred p): pred((MTpred )p->Copy()) {}
172			GiSTobject *Copy() const {
173			return new NotPred(pred);
174			}
175			~NotPred() { delete pred; }
176
177			// virtual methods
178			GiSTobjid IsA() { return MTPREDICATE_NOT_CLASS; }
179			double distance(const Object &obj) const {
180			return Sim2Dist(1-Dist2Sim(pred->distance(obj)));
181			}
182
183			// access to private members
184			MTpred *Pred() const { return pred; }
185
186			#ifdef PRINTING_OBJECTS
187			void Print(ostream& os) const {
188			os << "(!" << *pred << ")";
189			}
190			#endif
191
192			private:
193			MTpred *pred;
194			};
195
196			// for the queries, the conjunction corresponds to intersection, the disjunction to union, and the negation to difference
197
198			class MTquery: public GiSTobject { // the base class for queries
199			public:
200			// constructors, destructors, etc.
201			MTquery() : grade(0), isOpen(FALSE) {}
202			MTquery(const double g, const BOOL o=FALSE) : grade(g), isOpen(o) {}
203			virtual ~MTquery() {}
204
205			// pure virtual methods
206			virtual int Consistent(const GiSTentry& entry)=0;
207			virtual int NonConsistent(const GiSTentry& entry)=0;
208
209			// access to private members
210			double Grade() const { return grade; }
211			void SetGrade(double p_grade) { grade=p_grade; }
212
213			protected:
214			double grade;
215			BOOL isOpen;
216			};
217
218			class SimpleQuery : public MTquery { // a simple query
219			public:
220			// constructors, destructors, etc.
221			SimpleQuery(const MTpred p, const double r, const BOOL o=FALSE) : MTquery(0,o), pred((MTpred )p->Copy()), radius(r) {}
222			SimpleQuery(const SimpleQuery& q) : MTquery(q.grade, q.isOpen), pred((MTpred *)q.pred->Copy()), radius(q.radius) {}
223			GiSTobject *Copy() const {
224			return new SimpleQuery(*this);
225			}
226			~SimpleQuery() { delete pred; }
227
228			// basic consistency methods
229			int Consistent(const GiSTentry& entry);
230			int NonConsistent(const GiSTentry& entry);
231
232			// access to private members
233			double Radius() const { return radius; }
234			void SetRadius(double p_radius) { radius=p_radius; }
235
236			private:
237			MTpred *pred;
238			double radius;
239			};
240
241			class AndQuery : public MTquery { // the conjunction of two queries
242			public:
243			// constructors, destructors, etc.
244			AndQuery(const MTquery q1, const MTquery q2): q1((MTquery )q1->Copy()), q2((MTquery )q2->Copy()) {}
245			GiSTobject *Copy() const {
246			return new AndQuery(q1, q2);
247			}
248			~AndQuery() {
249			delete q1;
250			delete q2;
251			}
252
253			// basic consistency methods
254			int Consistent(const GiSTentry& entry) {
255			int response=q1->Consistent(entry)&&q2->Consistent(entry);
256
257			grade=MAX(q1->Grade(), q2->Grade());
258			return response;
259			}
260			int NonConsistent(const GiSTentry& entry) {
261			int response=q1->NonConsistent(entry)\|\|q2->NonConsistent(entry);
262
263			grade=MAX(q1->Grade(), q2->Grade()); // or what?
264			return response;
265			}
266
267			#ifdef PRINTING_OBJECTS
268			void Print(ostream& os) const {
269			os << "(" << q1 << " and " << q2 << ")";
270			}
271			#endif
272
273			private:
274			MTquery q1, q2;
275			};
276
277			class OrQuery : public MTquery { // the disjunction of two queries
278			public:
279			// constructors, destructors, etc.
280			OrQuery(const MTquery q1, const MTquery q2): q1((MTquery )q1->Copy()), q2((MTquery )q2->Copy()) {}
281			GiSTobject *Copy() const {
282			return new OrQuery(q1, q2);
283			}
284			~OrQuery() {
285			delete q1;
286			delete q2;
287			}
288
289			// basic consistency methods
290			int Consistent(const GiSTentry& entry) {
291			int response=q1->Consistent(entry)\|\|q2->Consistent(entry);
292
293			grade=MIN(q1->Grade(), q2->Grade());
294			return response;
295			}
296			int NonConsistent(const GiSTentry& entry) {
297			int response=q1->NonConsistent(entry)&&q2->NonConsistent(entry);
298
299			grade=MIN(q1->Grade(), q2->Grade()); // or what?
300			return response;
301			}
302
303			#ifdef PRINTING_OBJECTS
304			void Print(ostream& os) const {
305			os << "(" << q1 << " or " << q2 << ")";
306			}
307			#endif
308
309			private:
310			MTquery q1, q2;
311			};
312
313			class NotQuery: public MTquery { // the negation of a query
314			public:
315			// constructors, destructors, etc.
316			NotQuery(const MTquery q): q((MTquery )q->Copy()) {}
317			GiSTobject *Copy() const { return new NotQuery(q); }
318			~NotQuery() { delete q; }
319
320			// basic consistency methods
321			int Consistent(const GiSTentry& entry) {
322			int response=q->NonConsistent(entry);
323
324			grade=q->Grade();
325			return response;
326			}
327			int NonConsistent(const GiSTentry& entry) {
328			int response=q->Consistent(entry);
329
330			grade=q->Grade(); // or what?
331			return response;
332			}
333
334			#ifdef PRINTING_OBJECTS
335			void Print(ostream& os) const {
336			os << "(not " << *q << ")";
337			}
338			#endif
339
340			private:
341			MTquery *q;
342			};
343
344			class TopQuery: public GiSTobject { // a simple k-NN query
345			public:
346			// constructors, destructors, etc.
347	root	1.2	TopQuery(const MTpred p, const int n) : k(n), pred((MTpred )p->Copy()) {}
348			TopQuery(const TopQuery& q) : k(q.k), pred((MTpred *)q.pred->Copy()) {}
349	root	1.1	GiSTobject Copy() const { return new TopQuery(this); }
350			~TopQuery() { delete pred; }
351
352			// access to private members
353			const MTpred *Pred() const { return pred; }
354
355			int k;
356			private:
357			MTpred *pred;
358			};
359
360			#endif