Tree-M/PMT.cpp

#include <cstdlib>

#include "MT/MT.h"
#include "MT/MTpredicate.h"
#include "PMT.h"

const PMT *current_pmt;
int IOread, IOwrite;
dist2sim hfunction; // argl. using c++ without any clue.

/*
static double *
kdup (double *k, int ndims)
{
  double *n = new double [ndims];

  memcpy (n, k, ndims * sizeof (double));
  return n;
}
*/

double Object::distance(const Object& other) const
{
   int i;
   double dist = 0;

   for (i = NDIMS; i--; )
     {
       double d = other.k[i] - k[i];

       dist += d*d;
     }

   return dist;
}


Object::Object(double *pkey)
{
  k = pkey;

  // discretize the vector
  for (int i = NDIMS; i--; )
     k[i] = int2double (double2int (k[i]));
}

Object::Object(char *key)
{
  unsigned char *c = (unsigned char *)key;

  k = new double [NDIMS];

  for (int i = 0; i < NDIMS; i++)
    {
      unsigned long elem = 0;

      switch (ACC->elemsize)
        {
          case 4: elem |= *c++ << 24;
          case 3: elem |= *c++ << 16;
          case 2: elem |= *c++ <<  8;
          case 1: elem |= *c++ <<  0;
            break;
          default:
            abort ();
        }

      k[i] = int2double(elem);
    }
}

void Object::Compress(char *key)
{
  unsigned char *c = (unsigned char *)key;

  for (int i = 0; i < NDIMS; i++)
    {
      unsigned long elem = double2int (k[i]);

      switch (ACC->elemsize)
        {
          case 4: *c++ = (elem >> 24) & 0xff;
          case 3: *c++ = (elem >> 16) & 0xff;
          case 2: *c++ = (elem >>  8) & 0xff;
          case 1: *c++ = (elem >>  0) & 0xff;
            break;
          default:
            abort ();
        }
    }
}

#define SETCUR current_pmt = this

PMT::PMT(int ndims, double min, double max, double steps)
{
  this->ndims = ndims;
  this->min   = min;
  this->max   = max;
  this->steps = steps;

  if (steps <= (1<<8))
    elemsize = 1;
  else if (steps <= (1<<16))
    elemsize = 2;
  else if (steps <= (1<<24))
    elemsize = 3;
  else
    elemsize = 4;

  maxDist = (max - min) * (max - min) * ndims;

  SETCUR;
  mt = new MT;
}

PMT::~PMT()
{
  SETCUR;
  delete mt;
}

void PMT::create(const char *path)
{
  SETCUR;
  mt->Create(path);
}

void PMT::open(const char *path)
{
  SETCUR;
  mt->Open(path);
}

void PMT::insert(double *k, int data)
{
  SETCUR;
  Object o(k);
  const MTkey key(o, 0, 0);
  const MTentry entry(key, data);
  mt->Insert(entry);
}

double PMT::distance(double *k1, double *k2) const
{
  SETCUR;
  Object o1(k1), o2(k2);
  return o1.distance(o2);
}


void PMT::range(double *k, double r) const
{
  SETCUR;
  Object o(k);
  Pred p(o);
  SimpleQuery q(&p, r);
  GiSTlist<MTentry *> res = mt->RangeSearch(q);

  while(!res.IsEmpty())
    {
      MTentry *e = res.RemoveFront ();
      add_result(e->Ptr(), e->Key()->obj.data(), ndims);
      delete e;
    }
}

void PMT::top(double *k, int n) const
{
  SETCUR;
  Object o(k);
  Pred p(o);
  TopQuery q(&p, n);
  MTentry **res = mt->TopSearch(q);

  for (int i=0; i < n; i++)
    {
      MTentry *e = res[i];
      add_result(e->Ptr(), e->Key()->obj.data(), ndims);
      delete e;
   }
}

int PMT::maxlevel() const
{
  SETCUR;
  return mt->MaxLevel();
}
Revision:	1.3
Committed:	Sun May 6 17:28:24 2001 UTC (23 years ago) by root
Branch:	MAIN
Changes since 1.2:	+12 -2 lines
Log Message:	* empty log message *
#	Content
1	#include <cstdlib>
2
3	#include "MT/MT.h"
4	#include "MT/MTpredicate.h"
5	#include "PMT.h"
6
7	const PMT *current_pmt;
8	int IOread, IOwrite;
9	dist2sim hfunction; // argl. using c++ without any clue.
10
11	/*
12	static double *
13	kdup (double *k, int ndims)
14	{
15	double *n = new double [ndims];
16
17	memcpy (n, k, ndims * sizeof (double));
18	return n;
19	}
20	*/
21
22	double Object::distance(const Object& other) const
23	{
24	int i;
25	double dist = 0;
26
27	for (i = NDIMS; i--; )
28	{
29	double d = other.k[i] - k[i];
30
31	dist += d*d;
32	}
33
34	return dist;
35	}
36
37
38	Object::Object(double *pkey)
39	{
40	k = pkey;
41
42	// discretize the vector
43	for (int i = NDIMS; i--; )
44	k[i] = int2double (double2int (k[i]));
45	}
46
47	Object::Object(char *key)
48	{
49	unsigned char c = (unsigned char )key;
50
51	k = new double [NDIMS];
52
53	for (int i = 0; i < NDIMS; i++)
54	{
55	unsigned long elem = 0;
56
57	switch (ACC->elemsize)
58	{
59	case 4: elem \|= *c++ << 24;
60	case 3: elem \|= *c++ << 16;
61	case 2: elem \|= *c++ << 8;
62	case 1: elem \|= *c++ << 0;
63	break;
64	default:
65	abort ();
66	}
67
68	k[i] = int2double(elem);
69	}
70	}
71
72	void Object::Compress(char *key)
73	{
74	unsigned char c = (unsigned char )key;
75
76	for (int i = 0; i < NDIMS; i++)
77	{
78	unsigned long elem = double2int (k[i]);
79
80	switch (ACC->elemsize)
81	{
82	case 4: *c++ = (elem >> 24) & 0xff;
83	case 3: *c++ = (elem >> 16) & 0xff;
84	case 2: *c++ = (elem >> 8) & 0xff;
85	case 1: *c++ = (elem >> 0) & 0xff;
86	break;
87	default:
88	abort ();
89	}
90	}
91	}
92
93	#define SETCUR current_pmt = this
94
95	PMT::PMT(int ndims, double min, double max, double steps)
96	{
97	this->ndims = ndims;
98	this->min = min;
99	this->max = max;
100	this->steps = steps;
101
102	if (steps <= (1<<8))
103	elemsize = 1;
104	else if (steps <= (1<<16))
105	elemsize = 2;
106	else if (steps <= (1<<24))
107	elemsize = 3;
108	else
109	elemsize = 4;
110
111	maxDist = (max - min) * (max - min) * ndims;
112
113	SETCUR;
114	mt = new MT;
115	}
116
117	PMT::~PMT()
118	{
119	SETCUR;
120	delete mt;
121	}
122
123	void PMT::create(const char *path)
124	{
125	SETCUR;
126	mt->Create(path);
127	}
128
129	void PMT::open(const char *path)
130	{
131	SETCUR;
132	mt->Open(path);
133	}
134
135	void PMT::insert(double *k, int data)
136	{
137	SETCUR;
138	Object o(k);
139	const MTkey key(o, 0, 0);
140	const MTentry entry(key, data);
141	mt->Insert(entry);
142	}
143
144	double PMT::distance(double k1, double k2) const
145	{
146	SETCUR;
147	Object o1(k1), o2(k2);
148	return o1.distance(o2);
149	}
150
151
152	void PMT::range(double *k, double r) const
153	{
154	SETCUR;
155	Object o(k);
156	Pred p(o);
157	SimpleQuery q(&p, r);
158	GiSTlist<MTentry *> res = mt->RangeSearch(q);
159
160	while(!res.IsEmpty())
161	{
162	MTentry *e = res.RemoveFront ();
163	add_result(e->Ptr(), e->Key()->obj.data(), ndims);
164	delete e;
165	}
166	}
167
168	void PMT::top(double *k, int n) const
169	{
170	SETCUR;
171	Object o(k);
172	Pred p(o);
173	TopQuery q(&p, n);
174	MTentry **res = mt->TopSearch(q);
175
176	for (int i=0; i < n; i++)
177	{
178	MTentry *e = res[i];
179	add_result(e->Ptr(), e->Key()->obj.data(), ndims);
180	delete e;
181	}
182	}
183
184	int PMT::maxlevel() const
185	{
186	SETCUR;
187	return mt->MaxLevel();
188	}