/** Self-test. */
public static void _Main(string[] args)
{
const int ITER = 500;
const int RANGE = 65536;
SparseBitSet a = new SparseBitSet();
CUtility.ASSERT(!a.Get(0) && !a.Get(1));
CUtility.ASSERT(!a.Get(123329));
a.Set(0); CUtility.ASSERT(a.Get(0) && !a.Get(1));
a.Set(1); CUtility.ASSERT(a.Get(0) && a.Get(1));
a.clearAll();
CUtility.ASSERT(!a.Get(0) && !a.Get(1));
Random r = new Random();
Vector v = new Vector();
for (int n = 0; n < ITER; n++)
{
int rr = ((r.Next() >> 1) % RANGE) << 1;
a.Set(rr); v.addElement(rr);
// check that all the numbers are there.
CUtility.ASSERT(a.Get(rr) && !a.Get(rr + 1) && !a.Get(rr - 1));
for (int i = 0; i < v.size(); i++)
{
CUtility.ASSERT(a.Get((int)v.elementAt(i)));
}
}
SparseBitSet b = (SparseBitSet)a.Clone();
CUtility.ASSERT(a.Equals(b) && b.Equals(a));
for (int n = 0; n < ITER / 2; n++)
{
int rr = (r.Next() >> 1) % v.size();
int m = (int)v.elementAt(rr);
b.clear(m); v.removeElementAt(rr);
// check that numbers are removed properly.
CUtility.ASSERT(!b.Get(m));
}
CUtility.ASSERT(!a.Equals(b));
SparseBitSet c = (SparseBitSet)a.Clone();
SparseBitSet d = (SparseBitSet)a.Clone();
c.and(a);
CUtility.ASSERT(c.Equals(a) && a.Equals(c));
c.xor(a);
CUtility.ASSERT(!c.Equals(a) && c.size() == 0);
d.or(b);
CUtility.ASSERT(d.Equals(a) && !b.Equals(d));
d.and(b);
CUtility.ASSERT(!d.Equals(a) && b.Equals(d));
d.xor(a);
CUtility.ASSERT(!d.Equals(a) && !b.Equals(d));
c.or(d); c.or(b);
CUtility.ASSERT(c.Equals(a) && a.Equals(c));
c = (SparseBitSet)d.Clone();
c.and(b);
CUtility.ASSERT(c.size() == 0);
System.Console.WriteLine("Success.");
}
/***************************************************************
* Function: sortStates
**************************************************************/
private void sortStates
(
Vector nfa_set
)
{
CNfa elem;
int begin;
int size;
int index;
int value;
int smallest_index;
int smallest_value;
CNfa begin_elem;
size = nfa_set.size();
for (begin = 0; begin < size; ++begin)
{
elem = (CNfa)nfa_set.elementAt(begin);
smallest_value = elem.m_label;
smallest_index = begin;
for (index = begin + 1; index < size; ++index)
{
elem = (CNfa)nfa_set.elementAt(index);
value = elem.m_label;
if (value < smallest_value)
{
smallest_index = index;
smallest_value = value;
}
}
begin_elem = (CNfa)nfa_set.elementAt(begin);
elem = (CNfa)nfa_set.elementAt(smallest_index);
nfa_set.setElementAt(elem, begin);
nfa_set.setElementAt(begin_elem, smallest_index);
}
if (CUtility.OLD_DEBUG)
{
System.Console.Write("NFA vector indices: ");
for (index = 0; index < size; ++index)
{
elem = (CNfa)nfa_set.elementAt(index);
System.Console.Write(elem.m_label + " ");
}
System.Console.WriteLine();
}
return;
}
/***************************************************************
* Function: fix_dtrans
* Description: Updates CDTrans table after minimization
* using groups, removing redundant transition table states.
**************************************************************/
private void fix_dtrans
(
)
{
Vector new_vector;
int i;
int size;
Vector dtrans_group;
CDTrans first;
int c;
new_vector = new Vector();
size = m_spec.m_state_dtrans.Length;
for (i = 0; i < size; ++i)
{
if (CDTrans.F != m_spec.m_state_dtrans[i])
{
m_spec.m_state_dtrans[i] = m_ingroup[m_spec.m_state_dtrans[i]];
}
}
size = m_group.size();
for (i = 0; i < size; ++i)
{
dtrans_group = (Vector)m_group.elementAt(i);
first = (CDTrans)dtrans_group.elementAt(0);
new_vector.addElement(first);
for (c = 0; c < m_spec.m_dtrans_ncols; ++c)
{
if (CDTrans.F != first.m_dtrans[c])
{
first.m_dtrans[c] = m_ingroup[first.m_dtrans[c]];
}
}
}
m_group = null;
m_spec.m_dtrans_vector = new_vector;
}
/***************************************************************
* Function: pset
**************************************************************/
private void pset
(
Vector dtrans_group
)
{
int i;
int size;
CDTrans dtrans;
size = dtrans_group.size();
for (i = 0; i < size; ++i)
{
dtrans = (CDTrans)dtrans_group.elementAt(i);
System.Console.Write(dtrans.m_label + " ");
}
}
/***************************************************************
* Function: move
* Description: Returns null if resulting NFA Set is empty.
**************************************************************/
void move
(
Vector nfa_set,
SparseBitSet nfa_bit,
int b,
CBunch bunch
)
{
int size;
int index;
CNfa state;
bunch.m_nfa_set = null;
bunch.m_nfa_bit = null;
size = nfa_set.Count;
// System.Console.WriteLine(size);
for (index = 0; index < size; ++index)
{
state = (CNfa)nfa_set.elementAt(index);
// System.Console.WriteLine(index+" "+state.m_set);
if (b == state.m_edge ||
(CNfa.CCL == state.m_edge &&
true == state.m_set.contains(b)))
{
// System.Console.WriteLine(state.m_edge+" "+b);
if (null == bunch.m_nfa_set)
{
if (CUtility.DEBUG)
{
CUtility.ASSERT(null == bunch.m_nfa_bit);
}
bunch.m_nfa_set = new Vector();
/*bunch.m_nfa_bit
* = new SparseBitSet(m_spec.m_nfa_states.size());*/
bunch.m_nfa_bit = new SparseBitSet();
}
bunch.m_nfa_set.addElement(state.m_next);
/*System.Console.WriteLine("Size of bitset: " + bunch.m_nfa_bit.size());
* System.Console.WriteLine("Reference index: " + state.m_next.m_label);
* System.out.flush();*/
bunch.m_nfa_bit.Set(state.m_next.m_label);
}
}
if (null != bunch.m_nfa_set)
{
if (CUtility.DEBUG)
{
CUtility.ASSERT(null != bunch.m_nfa_bit);
}
sortStates(bunch.m_nfa_set);
}
return;
}
/***************************************************************
* Function: init_groups
* Description:
**************************************************************/
private void init_groups
(
)
{
int i;
int j;
int group_count;
int size;
// CAccept accept;
CDTrans dtrans;
Vector dtrans_group;
CDTrans first;
bool group_found;
m_group = new Vector();
group_count = 0;
size = m_spec.m_dtrans_vector.size();
m_ingroup = new int[size];
for (i = 0; i < size; ++i)
{
group_found = false;
dtrans = (CDTrans)m_spec.m_dtrans_vector.elementAt(i);
if (CUtility.DEBUG)
{
CUtility.ASSERT(i == dtrans.m_label);
CUtility.ASSERT(false == group_found);
CUtility.ASSERT(group_count == m_group.size());
}
for (j = 0; j < group_count; ++j)
{
dtrans_group = (Vector)m_group.elementAt(j);
if (CUtility.DEBUG)
{
CUtility.ASSERT(false == group_found);
CUtility.ASSERT(0 < dtrans_group.size());
}
first = (CDTrans)dtrans_group.elementAt(0);
if (CUtility.SLOW_DEBUG)
{
CDTrans check;
int k;
int s;
s = dtrans_group.size();
CUtility.ASSERT(0 < s);
for (k = 1; k < s; ++k)
{
check = (CDTrans)dtrans_group.elementAt(k);
CUtility.ASSERT(check.m_accept == first.m_accept);
}
}
if (first.m_accept == dtrans.m_accept)
{
dtrans_group.addElement(dtrans);
m_ingroup[i] = j;
group_found = true;
if (CUtility.DEBUG)
{
CUtility.ASSERT(j == m_ingroup[dtrans.m_label]);
}
break;
}
}
if (false == group_found)
{
dtrans_group = new Vector();
dtrans_group.addElement(dtrans);
m_ingroup[i] = m_group.size();
m_group.addElement(dtrans_group);
++group_count;
}
}
if (m_spec.m_verbose &&
true == CUtility.OLD_DUMP_DEBUG)
{
System.Console.WriteLine("Initial grouping:");
pgroups();
System.Console.WriteLine();
}
}
/***************************************************************
Function: pset
**************************************************************/
private void pset(
Vector dtrans_group
)
{
int i;
int size;
CDTrans dtrans;
size = dtrans_group.size();
for (i = 0; i < size; ++i)
{
dtrans = (CDTrans) dtrans_group.elementAt(i);
System.Console.Write(dtrans.m_label + " ");
}
}
/***************************************************************
Function: init_groups
Description:
**************************************************************/
private void init_groups(
)
{
int i;
int j;
int group_count;
int size;
// CAccept accept;
CDTrans dtrans;
Vector dtrans_group;
CDTrans first;
bool group_found;
m_group = new Vector();
group_count = 0;
size = m_spec.m_dtrans_vector.size();
m_ingroup = new int[size];
for (i = 0; i < size; ++i)
{
group_found = false;
dtrans = (CDTrans) m_spec.m_dtrans_vector.elementAt(i);
if (CUtility.DEBUG)
{
CUtility.ASSERT(i == dtrans.m_label);
CUtility.ASSERT(false == group_found);
CUtility.ASSERT(group_count == m_group.size());
}
for (j = 0; j < group_count; ++j)
{
dtrans_group = (Vector) m_group.elementAt(j);
if (CUtility.DEBUG)
{
CUtility.ASSERT(false == group_found);
CUtility.ASSERT(0 < dtrans_group.size());
}
first = (CDTrans) dtrans_group.elementAt(0);
if (CUtility.SLOW_DEBUG)
{
CDTrans check;
int k;
int s;
s = dtrans_group.size();
CUtility.ASSERT(0 < s);
for (k = 1; k < s; ++k)
{
check = (CDTrans) dtrans_group.elementAt(k);
CUtility.ASSERT(check.m_accept == first.m_accept);
}
}
if (first.m_accept == dtrans.m_accept)
{
dtrans_group.addElement(dtrans);
m_ingroup[i] = j;
group_found = true;
if (CUtility.DEBUG)
{
CUtility.ASSERT(j == m_ingroup[dtrans.m_label]);
}
break;
}
}
if (false == group_found)
{
dtrans_group = new Vector();
dtrans_group.addElement(dtrans);
m_ingroup[i] = m_group.size();
m_group.addElement(dtrans_group);
++group_count;
}
}
if (m_spec.m_verbose
&& true == CUtility.OLD_DUMP_DEBUG)
{
System.Console.WriteLine("Initial grouping:");
pgroups();
System.Console.WriteLine();
}
}
/***************************************************************
function: print_set
**************************************************************/
public void print_set(
Vector nfa_set
)
{
int size;
int elem;
CNfa nfa;
size = nfa_set.size();
if (0 == size)
{
System.Console.Write("empty ");
}
for (elem = 0; elem < size; ++elem)
{
nfa = (CNfa) nfa_set.elementAt(elem);
/*System.Console.Write(m_spec.m_nfa_states.indexOf(nfa) + " ");*/
System.Console.Write(nfa.m_label + " ");
}
}
/** Self-test. */
public static void _Main(string[] args)
{
const int ITER = 500;
const int RANGE= 65536;
SparseBitSet a = new SparseBitSet();
CUtility.ASSERT(!a.Get(0) && !a.Get(1));
CUtility.ASSERT(!a.Get(123329));
a.Set(0); CUtility.ASSERT(a.Get(0) && !a.Get(1));
a.Set(1); CUtility.ASSERT(a.Get(0) && a.Get(1));
a.clearAll();
CUtility.ASSERT(!a.Get(0) && !a.Get(1));
Random r = new Random();
Vector v = new Vector();
for (int n=0; n<ITER; n++)
{
int rr = ((r.Next()>>1) % RANGE) << 1;
a.Set(rr); v.addElement(rr);
// check that all the numbers are there.
CUtility.ASSERT(a.Get(rr) && !a.Get(rr+1) && !a.Get(rr-1));
for (int i=0; i<v.size(); i++)
CUtility.ASSERT(a.Get((int)v.elementAt(i)));
}
SparseBitSet b = (SparseBitSet) a.Clone();
CUtility.ASSERT(a.Equals(b) && b.Equals(a));
for (int n=0; n<ITER/2; n++)
{
int rr = (r.Next()>>1) % v.size();
int m = (int)v.elementAt(rr);
b.clear(m); v.removeElementAt(rr);
// check that numbers are removed properly.
CUtility.ASSERT(!b.Get(m));
}
CUtility.ASSERT(!a.Equals(b));
SparseBitSet c = (SparseBitSet) a.Clone();
SparseBitSet d = (SparseBitSet) a.Clone();
c.and(a);
CUtility.ASSERT(c.Equals(a) && a.Equals(c));
c.xor(a);
CUtility.ASSERT(!c.Equals(a) && c.size()==0);
d.or(b);
CUtility.ASSERT(d.Equals(a) && !b.Equals(d));
d.and(b);
CUtility.ASSERT(!d.Equals(a) && b.Equals(d));
d.xor(a);
CUtility.ASSERT(!d.Equals(a) && !b.Equals(d));
c.or(d); c.or(b);
CUtility.ASSERT(c.Equals(a) && a.Equals(c));
c = (SparseBitSet) d.Clone();
c.and(b);
CUtility.ASSERT(c.size()==0);
System.Console.WriteLine("Success.");
}
