// public static string IntToBinaryString(int number) {
// string binStr = "";
// while (number != 0) {
// binStr = (number & 1) + binStr;
// number = number >>> 1;
// }
// if (binStr == "")
// binStr = "0";
// return binStr;
// }
//
// public static string IntToBinaryString(long number) {
// string binStr = "";
// while (number > 0) {
// binStr = (number & 1) + binStr;
// number = number >>> 1;
// }
// if (binStr == "")
// binStr = "0";
// return binStr;
// }
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
public static Obj Copy(UnaryTable[] tables)
{
int count = 0;
for (int i = 0; i < tables.Length; i++)
{
count += tables[i].count;
}
if (count == 0)
{
return(EmptyRelObj.singleton);
}
Obj[] objs = new Obj[count];
int next = 0;
for (int i = 0; i < tables.Length; i++)
{
UnaryTable table = tables[i];
SurrObjMapper mapper = table.mapper;
long[] bitmap = table.bitmap;
for (int j = 0; j < bitmap.Length; j++)
{
long mask = bitmap[j];
for (int k = 0; k < 64; k++)
{
if (Miscellanea.BitIsSet64(mask, k))
{
objs[next++] = mapper(k + 64 * j);
}
}
}
}
Debug.Assert(next == count);
return(Builder.CreateSet(objs, objs.Length));
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
public static void Write(DataWriter writer, int fieldSymbId, BinaryTable[] tables, bool flipCols, int indentation, bool indentFirstLine, bool writeSeparator)
{
string baseWs = new string(Array.Repeat(' ', indentation));
string entryWs = new string(Array.Repeat(' ', indentation + 2));
int count = 0;
for (int i = 0; i < tables.Length; i++)
{
count += tables[i].Size();
}
if (indentFirstLine)
{
writer.Write(baseWs);
}
writer.Write(SymbObj.IdxToStr(fieldSymbId));
writer.Write(": [");
if (count > 0)
{
writer.Write("\n");
int written = 0;
for (int i = 0; i < tables.Length; i++)
{
BinaryTable table = tables[i];
SurrObjMapper mapper1 = table.mapper1;
SurrObjMapper mapper2 = table.mapper2;
BinaryTable.Iter it = table.GetIter();
while (!it.Done())
{
writer.Write(entryWs);
Obj obj1 = mapper1(it.Get1());
Obj obj2 = mapper2(it.Get2());
if (flipCols)
{
Obj tmp = obj1;
obj1 = obj2;
obj2 = tmp;
}
ObjPrinter.PrintNoFlush(obj1, writer);
writer.Write(", ");
ObjPrinter.PrintNoFlush(obj2, writer);
written++;
writer.Write(written < count || count == 1 ? ";\n" : "\n");
it.Next();
}
}
Debug.Assert(written == count);
writer.Write(baseWs);
}
writer.Write(writeSeparator ? "],\n" : "]\n");
}
//////////////////////////////////////////////////////////////////////////////
public static Obj Copy(SymBinaryTable[] tables)
{
int size = 0;
for (int i = 0; i < tables.Length; i++)
{
size += tables[i].Size();
}
if (size == 0)
{
return(EmptyRelObj.singleton);
}
Obj[] objs1 = new Obj[size];
Obj[] objs2 = new Obj[size];
int[] buffer = new int[32];
int next = 0;
for (int iT = 0; iT < tables.Length; iT++)
{
SymBinaryTable table = tables[iT];
OneWayBinTable oneWayTable = table.table;
SurrObjMapper mapper = table.mapper;
int len = oneWayTable.column.Length;
for (int iS = 0; iS < len; iS++)
{
int count1 = oneWayTable.Count(iS);
if (count1 != 0)
{
if (count1 > buffer.Length)
{
buffer = new int[Array.Capacity(buffer.Length, count1)];
}
Obj obj1 = mapper(iS);
int _count1 = oneWayTable.Restrict(iS, buffer);
Debug.Assert(_count1 == count1);
for (int i = 0; i < count1; i++)
{
int surr2 = buffer[i];
if (iS <= surr2)
{
objs1[next] = obj1;
objs2[next++] = mapper(surr2);
}
}
}
}
}
Debug.Assert(next == size);
return(Builder.CreateBinRel(objs1, objs2, size)); //## THIS COULD BE MADE MORE EFFICIENT
}
//////////////////////////////////////////////////////////////////////////////
public static Obj Copy(BinaryTable[] tables, bool flipped)
{
int count = 0;
for (int i = 0; i < tables.Length; i++)
{
count += tables[i].Size();
}
if (count == 0)
{
return(EmptyRelObj.singleton);
}
Obj[] objs1 = new Obj[count];
Obj[] objs2 = new Obj[count];
int[] buffer = new int[32];
int next = 0;
for (int iT = 0; iT < tables.Length; iT++)
{
BinaryTable table = tables[iT];
OneWayBinTable oneWayTable = table.table1;
SurrObjMapper mapper1 = table.mapper1;
SurrObjMapper mapper2 = table.mapper2;
int len = oneWayTable.column.Length;
for (int iS = 0; iS < len; iS++)
{
int count1 = oneWayTable.Count(iS);
if (count1 != 0)
{
if (count1 > buffer.Length)
{
buffer = new int[Array.Capacity(buffer.Length, count1)];
}
Obj obj1 = mapper1(iS);
int _count1 = oneWayTable.Restrict(iS, buffer);
Debug.Assert(_count1 == count1);
for (int i = 0; i < count1; i++)
{
objs1[next] = obj1;
objs2[next++] = mapper2(buffer[i]);
}
}
}
}
Debug.Assert(next == count);
return(Builder.CreateBinRel(flipped ? objs2 : objs1, flipped ? objs1 : objs2)); //## THIS COULD BE MADE MORE EFFICIENT
}
//////////////////////////////////////////////////////////////////////////////
public Sym12TernaryTable(SurrObjMapper mapper12, SurrObjMapper mapper3)
{
for (int i = 0; i < MinSize; i++)
{
SetEntry(i, i + 1, Empty, 0);
}
index123 = new Index(MinSize);
index12 = new Index(MinSize);
this.mapper12 = mapper12;
this.mapper3 = mapper3;
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
public static Obj Copy(TernaryTable[] tables, int idx1, int idx2, int idx3)
{
int count = 0;
for (int i = 0; i < tables.Length; i++)
{
count += tables[i].count;
}
if (count == 0)
{
return(EmptyRelObj.singleton);
}
Obj[] objs1 = new Obj[count];
Obj[] objs2 = new Obj[count];
Obj[] objs3 = new Obj[count];
int next = 0;
for (int iT = 0; iT < tables.Length; iT++)
{
TernaryTable table = tables[iT];
SurrObjMapper mapper1 = table.mapper1;
SurrObjMapper mapper2 = table.mapper2;
SurrObjMapper mapper3 = table.mapper3;
int size = table.Capacity();
for (int iS = 0; iS < size; iS++)
{
int field2 = table.Field2OrEmptyMarker(iS);
if (field2 != Empty)
{
objs1[next] = mapper1(table.Field1OrNext(iS));
objs2[next] = mapper2(field2);
objs3[next] = mapper3(table.Field3(iS));
next++;
}
}
}
Debug.Assert(next == count);
Obj[][] cols = new Obj[3][];
cols[idx1] = objs1;
cols[idx2] = objs2;
cols[idx3] = objs3;
return(Builder.CreateTernRel(cols[0], cols[1], cols[2], count));
}
public static void Write(DataWriter writer, int fieldSymbId, UnaryTable[] tables, int indentation, bool indentFirstLine, bool writeSeparator)
{
string baseWs = new string(Array.Repeat(' ', indentation));
string entryWs = new string(Array.Repeat(' ', indentation + 2));
int count = 0;
for (int i = 0; i < tables.Length; i++)
{
count += tables[i].Size();
}
if (indentFirstLine)
{
writer.Write(baseWs);
}
writer.Write(SymbObj.IdxToStr(fieldSymbId));
writer.Write(": [");
if (count > 0)
{
writer.Write("\n");
int written = 0;
for (int i = 0; i < tables.Length; i++)
{
UnaryTable table = tables[i];
SurrObjMapper mapper = table.mapper;
UnaryTable.Iter it = table.GetIter();
while (!it.Done())
{
writer.Write(entryWs);
Obj obj = mapper(it.Get());
ObjPrinter.PrintNoFlush(obj, writer);
written++;
writer.Write(written < count ? ",\n" : "\n");
it.Next();
}
}
Debug.Assert(written == count);
writer.Write(baseWs);
}
writer.Write(writeSeparator ? "],\n" : "]\n");
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
public static Obj Copy(Sym12TernaryTable[] tables)
{
int count = 0;
for (int i = 0; i < tables.Length; i++)
{
count += tables[i].count;
}
if (count == 0)
{
return(EmptyRelObj.singleton);
}
Obj[] col1 = new Obj[count];
Obj[] col2 = new Obj[count];
Obj[] col3 = new Obj[count];
int next = 0;
for (int iT = 0; iT < tables.Length; iT++)
{
Sym12TernaryTable table = tables[iT];
SurrObjMapper mapper12 = table.mapper12;
SurrObjMapper mapper3 = table.mapper3;
int size = table.Capacity();
for (int iS = 0; iS < size; iS++)
{
int arg2 = table.Arg2OrEmptyMarker(iS);
if (arg2 != Empty)
{
col1[next] = mapper12(table.Arg1OrNext(iS));
col2[next] = mapper12(arg2);
col3[next] = mapper3(table.Arg3(iS));
next++;
}
}
}
Debug.Assert(next == count);
return(Builder.CreateTernRel(col1, col2, col3, count));
}
protected ColumnBase(SurrObjMapper mapper)
{
this.mapper = mapper;
}
//////////////////////////////////////////////////////////////////////////////
public IntColumn(SurrObjMapper mapper) : base(mapper)
{
Array.Fill(column, NULL);
this.mapper = mapper;
}
public BinaryTable(SurrObjMapper mapper1, SurrObjMapper mapper2)
{
this.mapper1 = mapper1;
this.mapper2 = mapper2;
Check();
}
//////////////////////////////////////////////////////////////////////////////
public ObjColumn(SurrObjMapper mapper) : base(mapper)
{
this.mapper = mapper;
}
public UnaryTable(SurrObjMapper mapper)
{
this.mapper = mapper;
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
public static void Write(DataWriter writer, int fieldSymbId, ColumnBase[] columns, bool flipCols, int indentation, bool indentFirstLine, bool writeSeparator)
{
string baseWs = new string(Array.Repeat(' ', indentation));
string entryWs = new string(Array.Repeat(' ', indentation + 2));
int count = 0;
for (int i = 0; i < columns.Length; i++)
{
count += columns[i].Size();
}
if (indentFirstLine)
{
writer.Write(baseWs);
}
writer.Write(SymbObj.IdxToStr(fieldSymbId));
writer.Write(": [");
if (count > 0)
{
writer.Write("\n");
int written = 0;
for (int i = 0; i < columns.Length; i++)
{
ColumnBase col = columns[i];
SurrObjMapper mapper = col.mapper;
if (col is IntColumn)
{
IntColumn intCol = (IntColumn)col;
IntColumn.Iter it = intCol.GetIter();
while (!it.Done())
{
writer.Write(entryWs);
Obj key = mapper(it.GetIdx());
long value = it.GetValue();
if (flipCols)
{
writer.Write(value);
writer.Write(", ");
ObjPrinter.PrintNoFlush(key, writer);
written++;
writer.Write(written == 1 | written < count ? ";\n" : "\n");
}
else
{
ObjPrinter.PrintNoFlush(key, writer);
writer.Write(" -> ");
writer.Write(value);
written++;
writer.Write(written < count ? ",\n" : "\n");
}
it.Next();
}
}
else if (col is FloatColumn)
{
FloatColumn floatCol = (FloatColumn)col;
FloatColumn.Iter it = floatCol.GetIter();
while (!it.Done())
{
writer.Write(entryWs);
Obj key = mapper(it.GetIdx());
double value = it.GetValue();
if (flipCols)
{
writer.Write(FloatObjPrinter.Print(value));
writer.Write(", ");
ObjPrinter.PrintNoFlush(key, writer);
written++;
writer.Write(written == 1 | written < count ? ";\n" : "\n");
}
else
{
ObjPrinter.PrintNoFlush(key, writer);
writer.Write(" -> ");
writer.Write(FloatObjPrinter.Print(value));
written++;
writer.Write(written < count ? ",\n" : "\n");
}
it.Next();
}
}
else
{
ObjColumn objCol = (ObjColumn)col;
ObjColumn.Iter it = objCol.GetIter();
while (!it.Done())
{
writer.Write(entryWs);
Obj key = mapper(it.GetIdx());
Obj value = it.GetValue();
if (flipCols)
{
ObjPrinter.PrintNoFlush(value, writer);
writer.Write(", ");
ObjPrinter.PrintNoFlush(key, writer);
written++;
writer.Write(written == 1 | written < count ? ";\n" : "\n");
}
else
{
ObjPrinter.PrintNoFlush(key, writer);
writer.Write(" -> ");
ObjPrinter.PrintNoFlush(value, writer);
written++;
writer.Write(written < count ? ",\n" : "\n");
}
it.Next();
}
}
}
Debug.Assert(written == count);
writer.Write(baseWs);
}
writer.Write(writeSeparator ? "],\n" : "]\n");
}
//////////////////////////////////////////////////////////////////////////////
public FloatColumn(SurrObjMapper mapper) : base(mapper)
{
Debug.Assert(FloatObj.IsNaN(NULL));
Array.Fill(column, NULL);
this.mapper = mapper;
}
public SymBinaryTable(SurrObjMapper mapper)
{
this.mapper = mapper;
Check();
}
