FAS/src/bitvector.cpp

/**********************************************************************
*           Copyright (C) 2002-2003 by Gezelter's Group
*This program is free software; you can redistribute it and/or modify
*it under the terms of the GNU General Public License as published by
*the Free Software Foundation version 2 of the License.
*
*This program is distributed in the hope that it will be useful,
*but WITHOUT ANY WARRANTY; without even the implied warranty of
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*GNU General Public License for more details.
*
************************************************************************
*Author: Teng Lin               Email:  tlin@nd.edu
*Date: 08/13/2002               Version: 1.0
*
************************************************************************
*Description:
*
***********************************************************************/
#include "bitvector.h"
/***********************************************************************
* Class TBitVector
***********************************************************************/
//
void TBitVector::Resize(int newSize)
{
  if (newSize > Count())
  {
    this->insert(this->end(), newSize-Count(), false);
  }
  else if (newSize < Count())
  {
    this->erase(this->begin()+Count()-newSize, this->end());
  }
  else
  {
    return;
  }
}

bool TBitVector::IsEmpty()
{
  return (Count() == 0);
}

// bit operation
void TBitVector::SetBitOn(int index)
{
  (*this)[index] = true;
}

void TBitVector::SetBitOff(int index)
{
  (*this)[index] = false;
}

void TBitVector::SetRangeOn(int begin, int end)
{
  for(int i=begin; i<end; i++)
    SetBitOn(i);
}


void TBitVector::SetRangeOff(int begin, int end)
{
  for(int i=begin; i<end; i++)
    SetBitOff(i);
}

void TBitVector::SetAllOn()
{
  SetRangeOn(0,Count());
}

void TBitVector::SetAllOff()
{
  SetRangeOff(0,Count());
}

//
bool TBitVector::IsBitOn(int index)
{
  return (*this)[index];
}

// oveload operators
TBitVector& TBitVector::operator =(const TBitVector &src)
{
  int i;
  if (Count() < src.size())
  {
    Resize(src.size());
  }

  for (i=0; i<src.size(); i++)
  {
    (*this)[i] = src[i];
  }

  for (; i<Count();i++)
  {
    (*this)[i] = false;
  }

  return *this;
}

TBitVector& TBitVector::operator &=(const TBitVector &src)
{
  int i;
  if (Count() < src.size())
  {
    Resize(src.size());
  }

  for (i=0; i<src.size(); i++)
  {
    (*this)[i] = (*this)[i] & src[i];
  }

  for (; i<Count();i++)
  {
    (*this)[i] = false;
  }

  return *this;
}

TBitVector& TBitVector::operator |=(const TBitVector &src)
{
  int i;
  if (Count() < src.size())
  {
    Resize(src.size());
  }

  for (i=0; i<src.size(); i++)
  {
    (*this)[i] = (*this)[i] | src[i];
  }

  return *this;

}

TBitVector& TBitVector::operator ^=(const TBitVector &src)
{
  int i;
  if (Count() < src.size())
  {
    Resize(src.size());
  }

  for (i=0; i<src.size(); i++)
  {
    (*this)[i] = (*this)[i] ^ src[i];
  }

  return *this;
}

TBitVector& TBitVector::operator -=(const TBitVector &src)
{
  TBitVector tmp_bv;

  tmp_bv = (*this) ^ src;
  *this &= tmp_bv;
  return *this;
}

TBitVector& TBitVector::operator |=(const int i)
{
  SetBitOn(i);
}

/*----------------------------------------------------------------------------*/
void TBitVector::FromIntVec(vector<int> &intVec)
{
  int max;
  vector<int>::iterator i;


  for(i=intVec.begin(); i<intVec.end(); i++)
  {
    if (*i > max)
      max = *i;
  }

  Resize(max);
  SetAllOff();

  for(i=intVec.begin(); i<intVec.end(); i++)
  {
    SetBitOn(*i);
  }

}

void TBitVector::ToIntvec(vector<int> &intVec)
{
  intVec.clear();

  for(int i=0; i<Count(); i++)
  {
    if ((*this)[i])
      intVec.push_back(i);
  }
}

/***********************************************************************
* friend function of TBitVector
***********************************************************************/
TBitVector operator &(const TBitVector& bv1, const TBitVector& bv2)
{
  TBitVector tmp_bv;

  tmp_bv = bv1;
  tmp_bv &= bv2;

  return tmp_bv;
}

TBitVector operator |(const TBitVector& bv1, const TBitVector& bv2)
{
  TBitVector tmp_bv;

  tmp_bv = bv1;
  tmp_bv |= bv2;

  return tmp_bv;
}

TBitVector operator ^(const TBitVector& bv1, const TBitVector& bv2)
{
  TBitVector tmp_bv;

  tmp_bv = bv1;
  tmp_bv ^= bv2;

  return tmp_bv;
}

TBitVector operator -(const TBitVector& bv1, const TBitVector& bv2)
{
  TBitVector tmp_bv;

  tmp_bv = bv1 ^ bv2;
  tmp_bv &= bv1;

  return tmp_bv;

}

bool operator ==(const TBitVector& bv1, const TBitVector& bv2)
{

}
Revision:	74
Committed:	Wed Aug 14 19:56:11 2002 UTC (21 years, 10 months ago) by tim
File size:	4569 byte(s)
Log Message:	* empty log message *
#	Content
1	/**********************************************************************
2	* Copyright (C) 2002-2003 by Gezelter's Group
3	*This program is free software; you can redistribute it and/or modify
4	*it under the terms of the GNU General Public License as published by
5	*the Free Software Foundation version 2 of the License.
6	*
7	*This program is distributed in the hope that it will be useful,
8	*but WITHOUT ANY WARRANTY; without even the implied warranty of
9	*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10	*GNU General Public License for more details.
11	*
12	************************************************************************
13	*Author: Teng Lin Email: tlin@nd.edu
14	*Date: 08/13/2002 Version: 1.0
15	*
16	************************************************************************
17	*Description:
18	*
19	***********************************************************************/
20	#include "bitvector.h"
21	/***********************************************************************
22	* Class TBitVector
23	***********************************************************************/
24	//
25	void TBitVector::Resize(int newSize)
26	{
27	if (newSize > Count())
28	{
29	this->insert(this->end(), newSize-Count(), false);
30	}
31	else if (newSize < Count())
32	{
33	this->erase(this->begin()+Count()-newSize, this->end());
34	}
35	else
36	{
37	return;
38	}
39	}
40
41	bool TBitVector::IsEmpty()
42	{
43	return (Count() == 0);
44	}
45
46	// bit operation
47	void TBitVector::SetBitOn(int index)
48	{
49	(*this)[index] = true;
50	}
51
52	void TBitVector::SetBitOff(int index)
53	{
54	(*this)[index] = false;
55	}
56
57	void TBitVector::SetRangeOn(int begin, int end)
58	{
59	for(int i=begin; i<end; i++)
60	SetBitOn(i);
61	}
62
63
64	void TBitVector::SetRangeOff(int begin, int end)
65	{
66	for(int i=begin; i<end; i++)
67	SetBitOff(i);
68	}
69
70	void TBitVector::SetAllOn()
71	{
72	SetRangeOn(0,Count());
73	}
74
75	void TBitVector::SetAllOff()
76	{
77	SetRangeOff(0,Count());
78	}
79
80	//
81	bool TBitVector::IsBitOn(int index)
82	{
83	return (*this)[index];
84	}
85
86	// oveload operators
87	TBitVector& TBitVector::operator =(const TBitVector &src)
88	{
89	int i;
90	if (Count() < src.size())
91	{
92	Resize(src.size());
93	}
94
95	for (i=0; i<src.size(); i++)
96	{
97	(*this)[i] = src[i];
98	}
99
100	for (; i<Count();i++)
101	{
102	(*this)[i] = false;
103	}
104
105	return *this;
106	}
107
108	TBitVector& TBitVector::operator &=(const TBitVector &src)
109	{
110	int i;
111	if (Count() < src.size())
112	{
113	Resize(src.size());
114	}
115
116	for (i=0; i<src.size(); i++)
117	{
118	(this)[i] = (this)[i] & src[i];
119	}
120
121	for (; i<Count();i++)
122	{
123	(*this)[i] = false;
124	}
125
126	return *this;
127	}
128
129	TBitVector& TBitVector::operator \|=(const TBitVector &src)
130	{
131	int i;
132	if (Count() < src.size())
133	{
134	Resize(src.size());
135	}
136
137	for (i=0; i<src.size(); i++)
138	{
139	(this)[i] = (this)[i] \| src[i];
140	}
141
142	return *this;
143
144	}
145
146	TBitVector& TBitVector::operator ^=(const TBitVector &src)
147	{
148	int i;
149	if (Count() < src.size())
150	{
151	Resize(src.size());
152	}
153
154	for (i=0; i<src.size(); i++)
155	{
156	(this)[i] = (this)[i] ^ src[i];
157	}
158
159	return *this;
160	}
161
162	TBitVector& TBitVector::operator -=(const TBitVector &src)
163	{
164	TBitVector tmp_bv;
165
166	tmp_bv = (*this) ^ src;
167	*this &= tmp_bv;
168	return *this;
169	}
170
171	TBitVector& TBitVector::operator \|=(const int i)
172	{
173	SetBitOn(i);
174	}
175
176	/----------------------------------------------------------------------------/
177	void TBitVector::FromIntVec(vector<int> &intVec)
178	{
179	int max;
180	vector<int>::iterator i;
181
182
183	for(i=intVec.begin(); i<intVec.end(); i++)
184	{
185	if (*i > max)
186	max = *i;
187	}
188
189	Resize(max);
190	SetAllOff();
191
192	for(i=intVec.begin(); i<intVec.end(); i++)
193	{
194	SetBitOn(*i);
195	}
196
197	}
198
199	void TBitVector::ToIntvec(vector<int> &intVec)
200	{
201	intVec.clear();
202
203	for(int i=0; i<Count(); i++)
204	{
205	if ((*this)[i])
206	intVec.push_back(i);
207	}
208	}
209
210	/***********************************************************************
211	* friend function of TBitVector
212	***********************************************************************/
213	TBitVector operator &(const TBitVector& bv1, const TBitVector& bv2)
214	{
215	TBitVector tmp_bv;
216
217	tmp_bv = bv1;
218	tmp_bv &= bv2;
219
220	return tmp_bv;
221	}
222
223	TBitVector operator \|(const TBitVector& bv1, const TBitVector& bv2)
224	{
225	TBitVector tmp_bv;
226
227	tmp_bv = bv1;
228	tmp_bv \|= bv2;
229
230	return tmp_bv;
231	}
232
233	TBitVector operator ^(const TBitVector& bv1, const TBitVector& bv2)
234	{
235	TBitVector tmp_bv;
236
237	tmp_bv = bv1;
238	tmp_bv ^= bv2;
239
240	return tmp_bv;
241	}
242
243	TBitVector operator -(const TBitVector& bv1, const TBitVector& bv2)
244	{
245	TBitVector tmp_bv;
246
247	tmp_bv = bv1 ^ bv2;
248	tmp_bv &= bv1;
249
250	return tmp_bv;
251
252	}
253
254	bool operator ==(const TBitVector& bv1, const TBitVector& bv2)
255	{
256
257	}