public static PClosestPointOnSegment ClosestPointOnSegment(IList <Vector> ABs, Vector Pt)
{
HDebug.Assert(ABs.Count >= 2);
Vector closest = ABs[0];
//Tuple<Vector,Vector> closest_segment = new Tuple<Vector,Vector>(ABs[0], ABs[1]);
double closest_dist2 = (closest - Pt).Dist2;
double closest_dist = Math.Sqrt(closest_dist2);
int closest_iAB = 0;
for (int i = 1; i < ABs.Count; i++)
{
int iAB = i - 1;
Vector A = ABs[iAB];
Vector B = ABs[iAB + 1];
Vector C = ClosestPointOnLine(A, B, Pt, true);
double C_dist2 = (C - Pt).Dist2;
if (C_dist2 < closest_dist2)
{
closest = C;
closest_dist2 = C_dist2;
closest_dist = Math.Sqrt(C_dist2);
closest_iAB = iAB;
//closest_segment = new Tuple<Vector, Vector>(A, B);
}
}
HDebug.AssertTolerance(0.00000001, closest_dist - DistPointSegment(Pt, ABs));
return(new PClosestPointOnSegment
{
point = closest,
dist = closest_dist,
iAB = closest_iAB,
//segment = closest_segment,
});
}
public static void HLayeredArray2_selftest()
{
if (HLayeredArray2_doselftest == false)
{
return;
}
HLayeredArray2_doselftest = false;
HDebug.Assert((new HLayeredArray2 <int>(0, 1, 2)).ArrLength == 1);
HDebug.Assert((new HLayeredArray2 <int>(0, 2, 2)).ArrLength == 1);
HDebug.Assert((new HLayeredArray2 <int>(0, 3, 2)).ArrLength == 2);
HDebug.Assert((new HLayeredArray2 <int>(0, 4, 2)).ArrLength == 2);
HDebug.Assert((new HLayeredArray2 <int>(0, 5, 2)).ArrLength == 3);
HDebug.Assert((new HLayeredArray2 <int>(0, 6, 2)).ArrLength == 3);
HLayeredArray2 <int> arr = new HLayeredArray2 <int>(0, 5, 3);
HDebug.Assert(arr.Count == 0, arr[0] == 0, arr[1] == 0, arr[2] == 0, arr[3] == 0, arr[4] == 0);
arr[0] = 1; HDebug.Assert(arr.ArrCount == 1, arr[0] == 1, arr[1] == 0, arr[2] == 0, arr[3] == 0, arr[4] == 0);
arr[1] = 2; HDebug.Assert(arr.ArrCount == 1, arr[0] == 1, arr[1] == 2, arr[2] == 0, arr[3] == 0, arr[4] == 0);
arr[2] = 3; HDebug.Assert(arr.ArrCount == 1, arr[0] == 1, arr[1] == 2, arr[2] == 3, arr[3] == 0, arr[4] == 0);
arr[3] = 4; HDebug.Assert(arr.ArrCount == 2, arr[0] == 1, arr[1] == 2, arr[2] == 3, arr[3] == 4, arr[4] == 0);
arr[4] = 5; HDebug.Assert(arr.ArrCount == 2, arr[0] == 1, arr[1] == 2, arr[2] == 3, arr[3] == 4, arr[4] == 5);
arr[0] = 0; HDebug.Assert(arr.ArrCount == 2, arr[0] == 0, arr[1] == 2, arr[2] == 3, arr[3] == 4, arr[4] == 5);
arr[3] = 0; HDebug.Assert(arr.ArrCount == 2, arr[0] == 0, arr[1] == 2, arr[2] == 3, arr[3] == 0, arr[4] == 5);
arr[1] = 0; HDebug.Assert(arr.ArrCount == 2, arr[0] == 0, arr[1] == 0, arr[2] == 3, arr[3] == 0, arr[4] == 5);
arr[2] = 0; HDebug.Assert(arr.ArrCount == 1, arr[0] == 0, arr[1] == 0, arr[2] == 0, arr[3] == 0, arr[4] == 5);
arr[4] = 0; HDebug.Assert(arr.ArrCount == 0, arr[0] == 0, arr[1] == 0, arr[2] == 0, arr[3] == 0, arr[4] == 0);
}
public static T Deserialize <T>(string filename, int?ver)
{
object[] objs;
HDebug.Verify(_Deserialize(filename, ver, out objs));
HDebug.Assert(objs.Length == 1);
return((T)objs[0]);
}
public static MatrixByArr MD(MatrixByArr M, Vector D)
{ // M * Diag(D)
if (MD_SelfTest)
{
MD_SelfTest = false;
MatrixByArr tM = new double[3, 3] {
{ 1, 2, 3 }
, { 4, 5, 6 }
, { 7, 8, 9 }
};
Vector tD = new double[3] {
1, 2, 3
};
MatrixByArr tMD0 = new double[3, 3] {
{ 1, 4, 9 }
, { 4, 10, 18 }
, { 7, 16, 27 }
};
MatrixByArr tMD1 = MD(tM, tD);
MatrixByArr dtMD = tMD0 - tMD1;
double maxAbsDtMD = dtMD.ToArray().HAbs().HMax();
Debug.Assert(maxAbsDtMD == 0);
}
HDebug.Assert(M.RowSize == D.Size);
MatrixByArr lMD = new double[M.ColSize, M.RowSize];
for (int c = 0; c < lMD.ColSize; c++)
{
for (int r = 0; r < lMD.RowSize; r++)
{
lMD[c, r] = M[c, r] * D[r];
}
}
return(lMD);
}
public static Matrix DMD(Vector diagmat1, Matrix mat, Vector diagmat2)
{
if (DMD_selftest)
#region selftest
{
HDebug.ToDo("check");
DMD_selftest = false;
Vector td1 = new double[] { 1, 2, 3 };
Vector td2 = new double[] { 4, 5, 6 };
Matrix tm = new double[, ] {
{ 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }
};
Matrix dmd0 = LinAlg.Diag(td1) * tm * LinAlg.Diag(td2);
Matrix dmd1 = LinAlg.DMD(td1, tm, td2);
double err = (dmd0 - dmd1).HAbsMax();
HDebug.Assert(err == 0);
}
#endregion
Matrix DMD = mat.Clone();
for (int c = 0; c < mat.ColSize; c++)
{
for (int r = 0; r < mat.RowSize; r++)
{
double v0 = mat[c, r];
double v1 = diagmat1[c] * v0 * diagmat2[r];
if (v0 == v1)
{
continue;
}
DMD[c, r] = v1;
}
}
return(DMD);
}
internal Node <AvlNodeInfo> AvlInsert(T value)
{
HDebug.Assert(root == null || root.IsRoot());
AvlNodeInfo avlvalue = new AvlNodeInfo
{
value = value,
left_height = -1, // height of null node is -1
right_height = -1, // height of null node is -1
};
if (root == null)
{
Node <AvlNodeInfo> node = BstInsert <AvlNodeInfo>(null, ref root, avlvalue, avlcomp);
HDebug.Assert(root == node);
HDebug.Assert(root.left == null);
HDebug.Assert(root.right == null);
HDebug.Assert(root.value.height == 0);
return(node);
}
else
{
Node <AvlNodeInfo> node = BstInsert <AvlNodeInfo>(null, ref root, avlvalue, avlcomp);
HDebug.Assert(node.value.height == 0);
UpdateBalance(node, ref root);
return(node);
}
}
public static Vector DV(Matrix D, Vector V, bool assertDiag = true)
{
if (DV_SelfTest1)
{
DV_SelfTest1 = false;
MatrixByArr tD = new double[3, 3] {
{ 1, 0, 0 }, { 0, 2, 0 }, { 0, 0, 3 }
};
Vector tV = new double[3] {
1, 2, 3
};
Vector tDV = new double[3] {
1, 4, 9
};
// [1 0 0] [1] [1]
// [0 2 0] * [2] = [4]
// [0 0 3] [3] [9]
HDebug.AssertTolerance(double.Epsilon, DV(tD, tV) - tDV);
}
// D is the diagonal matrix
HDebug.Assert(D.ColSize == D.RowSize);
if (assertDiag) // check diagonal matrix
{
HDebug.AssertToleranceMatrix(double.Epsilon, D - Diag(Diag(D)));
}
HDebug.Assert(D.ColSize == V.Size);
Vector diagD = Diag(D);
Vector diagDV = DV(diagD, V);
return(diagDV);
}
public static double TorsionalAngle(Vector p1, Vector p2, Vector p3, Vector p4)
{
//function angle = torangle(atom1, atom2, atom3, atom4)
// plane_123 = cross(atom2-atom1, atom3-atom2); n1 = plane_123; n1 = n1 / sqrt(dot(n1,n1));
// plane_234 = cross(atom3-atom2, atom4-atom3); n2 = plane_234; n2 = n2 / sqrt(dot(n2,n2));
// vec_23 = atom3 - atom2; b = vec_23; b = b / sqrt(dot(b,b));
// angle = atan2(dot(cross(n1,n2),b), dot(n1,n2));
//end
Vector plane_123 = LinAlg.CrossProd(p2 - p1, p3 - p2); Vector n1 = plane_123.UnitVector();
Vector plane_234 = LinAlg.CrossProd(p3 - p2, p4 - p3); Vector n2 = plane_234.UnitVector();
Vector vec_23 = p3 - p2; Vector b = vec_23.UnitVector();
double angle = Math.Atan2(LinAlg.VtV(LinAlg.CrossProd(n1, n2), b), LinAlg.VtV(n1, n2));
{
Vector p12 = p2 - p1;
Vector p23 = p3 - p2;
Vector p34 = p4 - p3;
Vector nn1 = LinAlg.CrossProd(p12, p23).UnitVector();
Vector nn2 = LinAlg.CrossProd(p23, p34).UnitVector();
double a = AngleBetween(nn1, nn2);
HDebug.Assert(Math.Abs(Math.Abs(a) - Math.Abs(angle)) < 0.00000001);
}
return(angle);
}
public static List <List <TYPE> > ReadTable <TYPE>(string filename, Parser <TYPE> parser)
{
try
{
System.IO.StreamReader reader = new System.IO.StreamReader(filename);
List <List <TYPE> > table = new List <List <TYPE> >();
while (reader.EndOfStream == false)
{
string line = reader.ReadLine();
string[] values = line.Split(' ', ',', '\t');
List <TYPE> values_ = new List <TYPE>();
foreach (string value in values)
{
TYPE value_ = parser(value);
values_.Add(value_);
}
table.Add(values_);
}
reader.Close();
reader.Dispose();
return(table);
}
catch
{
HDebug.Assert(false);
throw;
}
}
int IList <T> .IndexOf(T item)
{
long indexof = IndexOf(item);
HDebug.Assert(indexof <= int.MaxValue);
return((int)indexof);
}
public void SetValue(int c, int r, double value)
{
int c0 = c / BlkSize; int c1 = c % BlkSize;
int r0 = r / BlkSize; int r1 = r % BlkSize;
if (value != 0)
{
// assign value
MatrixByArr lmat = blkmatrix[c0, r0];
lmat[c1, r1] = value;
blkmatrix[c0, r0] = lmat;
return;
}
HDebug.Assert(value == 0);
if (blkmatrix.HasElement(c0, r0))
{
MatrixByArr lmat = blkmatrix[c0, r0];
lmat[c1, r1] = value;
blkmatrix[c0, r0] = lmat;
return;
}
else
{
// (blkmatrix[c0,r0] == null) && (value == 0)
// do nothing
return;
}
}
public static double AngleBetween(Vector a, Vector b, Vector c)
{
if (AngleBetween_selftest2)
{
AngleBetween_selftest2 = false;
Vector ta, tb, tc;
double tang;
ta = new double[] { 1, 0, 0 };
tb = new double[] { 0, 0, 0 };
tc = new double[] { 0, 1, 0 };
tang = AngleBetween(ta, tb, tc);
HDebug.AssertTolerance(0.0001, Math.PI / 2 - tang);
ta = new double[] { 0, 1, 0 };
tb = new double[] { 0, 0, 0 };
tc = new double[] { 0, 1, 1 };
tang = AngleBetween(ta, tb, tc);
HDebug.AssertTolerance(0.0001, Math.PI / 4 - tang);
}
Vector left = a - b;
Vector right = c - b;
double ang = AngleBetween(left, right);
HDebug.Assert(ang >= 0);
HDebug.Assert(ang <= Math.PI);
return(ang);
}
public T this[long i]
{
get
{
int ii = (int)i;
HDebug.Assert(0 <= i, i < Size);
if (data.ContainsKey(ii))
{
return(data[ii]);
}
if (GetDefault != null)
{
return(GetDefault());
}
return(default(T));
}
set
{
int ii = (int)i;
HDebug.Assert(0 <= i, i < Size);
if (data.ContainsKey(ii))
{
data[ii] = value; return;
}
data.Add(ii, value);
}
}
public static double?GetRootSecant(Func <double, object, double> func, double p0, double p1, object etc, int maxiter, double tolFunc = 0.00000001, double tolP = 0.00000001)
{
double v0 = func(p0, etc);
double v1 = func(p1, etc);
for (int iter = 0; iter < maxiter; iter++)
{
if (Math.Abs(v1 - v0) < tolFunc)
{
//HDebug.AssertSimilar(v1, 0, 0.00000001);
return(p1);
}
if (Math.Abs(p0 - p1) < tolP)
{
//HDebug.AssertSimilar(v1, 0, 0.00000001);
return(p1);
}
double dv = -1 * v1 * (p1 - p0) / (v1 - v0);
p0 = p1; v0 = v1;
p1 = p1 + dv;
v1 = func(p1, etc);
HDebug.Assert(double.IsNaN(v1) == false);
}
if (Math.Abs(v1 - 0) < tolFunc)
{
return(p1);
}
return(null);
}
public static Vector GetRotAxis(MatrixByArr rot)
{
HDebug.ToDo("write selftest code");
// http://en.wikipedia.org/wiki/Rotation_matrix#Determining_the_axis
//
// Determining the axis
// Given a rotation matrix R, a vector u parallel to the rotation axis must satisfy
// R u = u
// since the rotation of u around the rotation axis must result in u. The equation
// above may be solved for u which is unique up to a scalar factor.
// Further, the equation may be rewritten
// R u = I u => (R-I) u = 0
// which shows that u is the null space of R-I. Viewed another way, u is an eigenvector
// of R corresponding to the eigenvalue λ=1(every rotation matrix must have this eigenvalue).
HDebug.Assert(IsRotMatrix(rot));
MatrixByArr RI = rot - LinAlg.Eye(3);
Vector[] eigvec;
double[] eigval;
NumericSolver.Eig(RI, out eigvec, out eigval);
int idx = eigval.HAbs().HIdxMin();
Vector axis = eigvec[idx];
return(axis);
}
public static int[] HIdxSorted <T>(this IList <T> values, Comparison <T> comparison)
{
Comparison <Tuple <T, int> > mycomparison = delegate(Tuple <T, int> x, Tuple <T, int> y)
{
return(comparison(x.Item1, y.Item1));
};
List <Tuple <T, int> > sorteds = new List <Tuple <T, int> >(values.Count);
for (int i = 0; i < values.Count; i++)
{
sorteds.Add(new Tuple <T, int>(values[i], i));
}
sorteds.Sort(mycomparison);
int[] idxs = new int[values.Count];
for (int i = 0; i < values.Count; i++)
{
idxs[i] = sorteds[i].Item2;
}
string debug = "false";
if (debug == "true")
{
HashSet <int> hsIdxs = new HashSet <int>(idxs);
HDebug.Assert(values.Count == hsIdxs.Count);
}
return(idxs);
}
public static void Derivative2 <INFO>(Func <Vector[], INFO, double> func, Vector[] x, double dx, ref MatrixByArr[,] dy2, INFO info)
{
// assume that (x[i].Size == 3)
int size = x.Length;
HDebug.Assert(dy2.GetLength(0) == size, dy2.GetLength(1) == size);
double dx2 = dx * dx;
Vectors xx = x;
for (int i = 0; i < size; i++)
{
for (int di = 0; di < 3; di++)
{
for (int j = 0; j < size; j++)
{
for (int dj = 0; dj < 3; dj++)
{
Vector[] x0 = xx.Clone(); x0[i][di] += dx; x0[j][dj] += dx; double y0 = func(x0, info);
Vector[] x1 = xx.Clone(); x1[i][di] -= dx; x1[j][dj] += dx; double y1 = func(x1, info);
Vector[] x2 = xx.Clone(); x2[i][di] += dx; x2[j][dj] -= dx; double y2 = func(x2, info);
Vector[] x3 = xx.Clone(); x3[i][di] -= dx; x3[j][dj] -= dx; double y3 = func(x3, info);
double d2f_didj = (y0 - y1 - y2 + y3) / (4 * dx2);
dy2[i, j][di, dj] = d2f_didj;
}
}
}
}
}
public List <Node> FindPathMST(Node from, IEnumerable <Node> tos, Func <List <Node>, List <Node>, int> selector)
{
HashSet <Node> toset = new HashSet <Node>(tos);
toset.Remove(null);
bool[] visited = new bool[nodes.Count];
List <Node> found = null;
List <Node> probing = new List <Node>();
Tree <Node> tree = BuildTreeMST(from, null);
foreach (Node to in toset)
{
Tree.Node treeto = tree.FindNode(to);
List <Tree.Node> treepath = tree.NodesFromRootTo(treeto);
List <Node> path = tree.GetValue(treepath);
if (path.Count == 0)
{
continue;
}
HDebug.Assert(path.First() == from, path.Last() == to);
if (found == null || selector(found, path) == 1)
{
found = path;
}
}
return(found);
}
public void ChangeComp(Comparison <T> comp)
{
Comparison <T> comp0 = _comp;
_comp = comp;
HDebug.Assert(Validate());
}
public static T2[,] HToType <T1, T2>(this T1[,] values)
{
if (values == null)
{
return(null);
}
T2[,] values2 = new T2[values.GetLength(0), values.GetLength(1)];
for (int i0 = 0; i0 < values.GetLength(0); i0++)
{
for (int i1 = 0; i1 < values.GetLength(1); i1++)
{
dynamic value = values[i0, i1];
T2 value2 = (T2)value;
if (value != null)
{
HDebug.Assert(value2 != null);
}
if (value == null)
{
HDebug.Assert(value2 == null);
}
values2[i0, i1] = value2;
}
}
return(values2);
}
public static Vector DV(Vector D, Vector V, bool assertDiag = true)
{
if (DV_SelfTest2)
{
DV_SelfTest2 = false;
Vector tD = new double[3] {
1, 2, 3
};
Vector tV = new double[3] {
1, 2, 3
};
Vector tDV = new double[3] {
1, 4, 9
};
// [1 0 0] [1] [1]
// [0 2 0] * [2] = [4]
// [0 0 3] [3] [9]
HDebug.AssertTolerance(double.Epsilon, DV(tD, tV) - tDV);
}
// D is the diagonal matrix
HDebug.Assert(D.Size == V.Size);
int size = V.Size;
Vector dv = new double[size];
for (int i = 0; i < size; i++)
{
dv[i] = D[i] * V[i];
}
return(dv);
}
public static T HMax <T>(this T[,,] values)
where T : IComparable <T>
{
int[] idxmax = HIdxMax(values);
HDebug.Assert(idxmax.Length == 3);
return(values[idxmax[0], idxmax[1], idxmax[2]]);
}
public static double V1tD2V3(Vector V1, Matrix D2, Vector V3, bool assertDiag = true)
{
if (V1tD2V3_SelfTest)
{
V1tD2V3_SelfTest = false;
Vector tV1 = new double[3] {
1, 2, 3
};
MatrixByArr tD2 = new double[3, 3] {
{ 2, 0, 0 }, { 0, 3, 0 }, { 0, 0, 4 }
};
Vector tV3 = new double[3] {
3, 4, 5
};
// [2 ] [3] [ 6]
// [1 2 3] * [ 3 ] * [4] = [1 2 3] * [12] = 6+24+60 = 90
// [ 4] [5] [20]
double tV1tD2V3 = 90;
HDebug.AssertTolerance(double.Epsilon, tV1tD2V3 - V1tD2V3(tV1, tD2, tV3));
}
if (assertDiag) // check diagonal matrix
{
HDebug.AssertToleranceMatrix(double.Epsilon, D2 - Diag(Diag(D2)));
}
HDebug.Assert(V1.Size == D2.ColSize);
HDebug.Assert(D2.RowSize == V3.Size);
Vector lD2V3 = DV(D2, V3, assertDiag);
double lV1tD2V3 = VtV(V1, lD2V3);
return(lV1tD2V3);
}
public static T HMin <T>(this T[,,] values)
where T : IComparable <T>
{
int[] idxmin = HIdxMin(values);
HDebug.Assert(idxmin.Length == 3);
return(values[idxmin[0], idxmin[1], idxmin[2]]);
}
public static double[,] GetMatrix(string name, int colsize, int rowsize)
{
double[,] matrix = GetMatrix(name);
HDebug.Assert(matrix.GetLength(0) == colsize);
HDebug.Assert(matrix.GetLength(1) == rowsize);
return(matrix);
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//public static Complex[] Roots2c(double p2, double p1, double p0)
//{
// Complex d = Complex.Sqrt(new Complex(p1 * p1 - 4 * p2 * p0));
// Complex[] roots = new Complex[2] {
// (-1*p1 + d)/(2*p2),
// (-1*p1 - d)/(2*p2)
// };
// return roots;
//}
public static double[] GetRootsClosedFormDegree2(double p2, double p1, double p0)
{
if (HDebug.Selftest())
{
double[] tsol;
tsol = GetRootsClosedFormDegree2(1, 2, -3);
HDebug.Assert(tsol[0] == 1, tsol[1] == -3);
tsol = GetRootsClosedFormDegree2(4, 3, 10);
HDebug.Assert(tsol == null);
}
double d = p1 * p1 - 4 * p2 * p0;
if (d >= 0)
{
d = Math.Sqrt(d);
double[] roots = new double[2] {
(-1 * p1 + d) / (2 * p2),
(-1 * p1 - d) / (2 * p2)
};
return(roots);
}
return(null);
}
public static bool IsZero(this Matrix mat)
{
if (IsZero_selftest)
{
IsZero_selftest = false;
HDebug.Assert(((MatrixByArr)(new double[2, 2] {
{ 0, 0 }, { 0, 0 }
})).IsZero() == true);
HDebug.Assert(((MatrixByArr)(new double[2, 2] {
{ 0, 0 }, { 0, 1 }
})).IsZero() == false);
}
for (int c = 0; c < mat.ColSize; c++)
{
for (int r = 0; r < mat.RowSize; r++)
{
if (mat[c, r] != 0)
{
return(false);
}
}
}
return(true);
}
public static void DSW <T>(ref Node <T> root)
{
if (DSW_selftest)
{
DSW_selftest = false;
Comparison <int> _compare = delegate(int a, int b) { return(a - b); };
Node <int> _root = null;
BstInsertRange(ref _root, new int[] { 43, 10, 12, 1, 49, 27, 40, 39, 30, 29, 18, 15, 2, 9, 44, 24, 3, 5, 37, 38, 34, 0, 35, 16, 21, 36, 23, 31, 19, 20, 42, 17, 11, 25, 47, 41, 48, 26, 14, 46 }, _compare);
HDebug.Assert(_root.IsBalanced() == false);
HDebug.Assert(_root.ToString() == "(((0,1,(_,2,((_,3,5),9,_))),10,(11,12,(((14,15,(_,16,17)),18,(((_,19,20),21,23),24,(_,25,26))),27,(((29,30,((31,34,(_,35,36)),37,38)),39,_),40,(41,42,_))))),43,((_,44,(46,47,48)),49,_))");
DSW(ref _root);
HDebug.Assert(_root.IsBalanced() == true);
HDebug.Assert(_root.ToString() == "(((((0,1,2),3,(5,9,10)),11,((12,14,15),16,(17,18,19))),20,(((21,23,_),24,25),26,(27,29,30))),31,(((34,35,36),37,(38,39,40)),41,((42,43,44),46,(47,48,49))))");
//cout << " 7) BST built with values : 43,10,12,1,49,27,40,39,30,29,18,15,2,9,44,24,3,5,37,38,34,0,35,16,21,36,23,31,19,20,42,17,11,25,47,41,48,26,14,46" << endl;
//int array[40] = { 43,10,12,1,49,27,40,39,30,29,18,15,2,9,44,24,3,5,37,38,34,0,35,16,21,36,23,31,19,20,42,17,11,25,47,41,48,26,14,46 };
//string bst_string = "(((0,1,(_,2,((_,3,5),9,_))),10,(11,12,(((14,15,(_,16,17)),18,(((_,19,20),21,23),24,(_,25,26))),27,(((29,30,((31,34,(_,35,36)),37,38)),39,_),40,(41,42,_))))),43,((_,44,(46,47,48)),49,_))";
//string backbone_string = "(_,0,(_,1,(_,2,(_,3,(_,5,(_,9,(_,10,(_,11,(_,12,(_,14,(_,15,(_,16,(_,17,(_,18,(_,19,(_,20,(_,21,(_,23,(_,24,(_,25,(_,26,(_,27,(_,29,(_,30,(_,31,(_,34,(_,35,(_,36,(_,37,(_,38,(_,39,(_,40,(_,41,(_,42,(_,43,(_,44,(_,46,(_,47,(_,48,49)))))))))))))))))))))))))))))))))))))))";
//string dsw_string = "(((((0,1,2),3,(5,9,10)),11,((12,14,15),16,(17,18,19))),20,(((21,23,_),24,25),26,(27,29,30))),31,(((34,35,36),37,(38,39,40)),41,((42,43,44),46,(47,48,49))))";
}
DSW_TreeToBackbone(ref root);
DSW_BackboneToACBT(ref root);
}
public int Compare(Elem x, Elem y)
{
if (x == y)
{
return(0);
}
if (x.node == y.node)
{
HDebug.Assert(false); return(0);
}
if (x.dist < y.dist)
{
return(-1);
}
if (x.dist > y.dist)
{
return(1);
}
if (x.node.id < y.node.id)
{
return(-1);
}
if (x.node.id > y.node.id)
{
return(1);
}
HDebug.Assert(false);
return(0);
}
public T GetAtLock(int c, int r)
{
HDebug.Assert(0 <= c, c < ColSize, 0 <= r, r < RowSize);
if (c == r)
{
lock (diagonal)
{
if (diagonal[c] != null)
{
return(diagonal[c]);
}
}
}
else
{
var offdiagonal_c = offdiagonal[c];
lock (offdiagonal_c)
{
if (offdiagonal_c.ContainsKey(r))
{
return(offdiagonal_c[r]);
}
}
}
if (GetDefault != null)
{
return(GetDefault());
}
return(default(T));
}