static double DeterminantDestructive(SimplexVolumeBuffer buff)
{
var A = buff.Data;
switch (buff.Dimension)
{
case 0: return(0.0);
case 1: return(A[0]);
case 2: return((A[0] * A[3]) - (A[1] * A[2]));
case 3: return((A[0] * A[4] * A[8]) + (A[1] * A[5] * A[6]) + (A[2] * A[3] * A[7])
- (A[0] * A[5] * A[7]) - (A[1] * A[3] * A[8]) - (A[2] * A[4] * A[6]));
default:
{
var iPiv = buff.Pivots;
var dim = buff.Dimension;
LUFactor(A, dim, iPiv, buff.Helper);
var det = 1.0;
for (int i = 0; i < iPiv.Length; i++)
{
det *= A[dim * i + i];
if (iPiv[i] != i)
{
det *= -1; // the determinant sign changes on row swap.
}
}
return(det);
}
}
}
private static double DeterminantDestructive(SimplexVolumeBuffer buff)
{
double[] data = buff.Data;
switch (buff.Dimension)
{
case 0:
return(0.0);
case 1:
return(data[0]);
case 2:
return((data[0] * data[3]) - (data[1] * data[2]));
case 3:
return(((((((data[0] * data[4]) * data[8]) + ((data[1] * data[5]) * data[6])) + ((data[2] * data[3]) * data[7])) - ((data[0] * data[5]) * data[7])) - ((data[1] * data[3]) * data[8])) - ((data[2] * data[4]) * data[6]));
}
int[] pivots = buff.Pivots;
int dimension = buff.Dimension;
LUFactor(data, dimension, pivots, buff.Helper);
double num3 = 1.0;
for (int i = 0; i < pivots.Length; i++)
{
num3 *= data[(dimension * i) + i];
if (pivots[i] != i)
{
num3 *= -1.0;
}
}
return(num3);
}
/// <summary>
/// Computes the volume of an n-dimensional simplex.
/// Buffer needs to be array of shape Dimension x Dimension.
/// </summary>
/// <param name="cell"></param>
/// <param name="vertices"></param>
/// <param name="buffer">Helper for the calculation to avoid unnecessary allocations.</param>
/// <returns></returns>
public static double GetSimplexVolume(ConvexFaceInternal cell, IList<IVertex> vertices, SimplexVolumeBuffer buffer)
{
var xs = cell.Vertices;
var pivot = vertices[xs[0]].Position;
var data = buffer.Data;
var dim = buffer.Dimension;
double f = 1.0;
for (int i = 1; i < xs.Length; i++)
{
f *= i + 1;
var point = vertices[xs[i]].Position;
for (int j = 0; j < point.Length; j++) data[j * dim + i - 1] = point[j] - pivot[j];
}
return Math.Abs(DeterminantDestructive(buffer)) / f;
}
/// <summary>
/// Computes the volume of an n-dimensional simplex.
/// Buffer needs to be array of shape Dimension x Dimension.
/// </summary>
/// <param name="cell"></param>
/// <param name="vertices"></param>
/// <param name="buffer">Helper for the calculation to avoid unnecessary allocations.</param>
/// <returns></returns>
public static double GetSimplexVolume(ConvexFaceInternal cell, IList <IVertex> vertices, SimplexVolumeBuffer buffer)
{
var xs = cell.Vertices;
var pivot = vertices[xs[0]].Position;
var data = buffer.Data;
var dim = buffer.Dimension;
double f = 1.0;
for (int i = 1; i < xs.Length; i++)
{
f *= i + 1;
var point = vertices[xs[i]].Position;
for (int j = 0; j < point.Length; j++)
{
data[j * dim + i - 1] = point[j] - pivot[j];
}
}
return(Math.Abs(DeterminantDestructive(buffer)) / f);
}
static double DeterminantDestructive(SimplexVolumeBuffer buff)
{
var A = buff.Data;
switch (buff.Dimension)
{
case 0: return 0.0;
case 1: return A[0];
case 2: return (A[0] * A[3]) - (A[1] * A[2]);
case 3: return (A[0] * A[4] * A[8]) + (A[1] * A[5] * A[6]) + (A[2] * A[3] * A[7])
- (A[0] * A[5] * A[7]) - (A[1] * A[3] * A[8]) - (A[2] * A[4] * A[6]);
default:
{
var iPiv = buff.Pivots;
var dim = buff.Dimension;
LUFactor(A, dim, iPiv, buff.Helper);
var det = 1.0;
for (int i = 0; i < iPiv.Length; i++)
{
det *= A[dim * i + i];
if (iPiv[i] != i) det *= -1; // the determinant sign changes on row swap.
}
return det;
}
}
}
public static double GetSimplexVolume(ConvexFaceInternal cell, IList <IVertex> vertices, SimplexVolumeBuffer buffer)
{
int[] numArray = cell.Vertices;
double[] position = vertices[numArray[0]].Position;
double[] data = buffer.Data;
int dimension = buffer.Dimension;
double num2 = 1.0;
int index = 1;
while (index < numArray.Length)
{
num2 *= index + 1;
double[] numArray4 = vertices[numArray[index]].Position;
int num4 = 0;
while (true)
{
if (num4 >= numArray4.Length)
{
index++;
break;
}
data[((num4 * dimension) + index) - 1] = numArray4[num4] - position[num4];
num4++;
}
}
return(Math.Abs(DeterminantDestructive(buffer)) / num2);
}
