public void CanBeComputedEvaluatesToTrue()
{
var dims = new TensorDimensions(3, 4, -1, 5) { Size = 3*4*5*13 };
Assert.True(dims.CanBeComputed);
Assert.Equal(13, dims[2]); // also check that the free dimension was correctly computed
}
public void ComputedDimCanBeOne()
{
var dims = new TensorDimensions(-1, 10) { Size = 10 };
Assert.True(dims.CanBeComputed);
Assert.Equal(1, dims[0]);
}
/// <summary>
/// In case of error, returns the originalDimensions and a non-empty error message in the output argument.
/// </summary>
public TensorDimensions TryToApply(TensorDimensions originalDimensions, out string errorMessage)
{
var dimsOrError = ComputeDimensions(originalDimensions.ElementCount);
errorMessage = dimsOrError.Item2?.Message ?? string.Empty;
return(dimsOrError.Item1 ?? originalDimensions);
}
public bool TryToApply(TensorDimensions originalDims, out TensorDimensions customDims)
{
TensorDimensions adjustedDims = TryComputeDimensions(originalDims.ElementCount);
customDims = adjustedDims ?? originalDims;
return(adjustedDims != null);
}
public void ApplyFallbackTheory(CustomDimensionsHint hint, TensorDimensions originalDims)
{
TensorDimensions resultDims;
bool didApply = hint.TryToApply(originalDims, out resultDims);
Assert.Equal(originalDims, resultDims);
Assert.False(didApply);
}
public void ConstructsWithVariableNumberOfParams()
{
var dims = new TensorDimensions(2, 3);
Assert.Equal(2, dims.Count);
Assert.Equal(2, dims[0]);
Assert.Equal(3, dims[1]);
Assert.False(dims.IsCustom); // dimensions created in code are "default" and should not be saved to project
}
public CustomDimsTestCase(TensorDimensions dims, CustomDimensionsHint customDims,
RenderingMethod method, int vectorElements, Size expectedSize)
{
Dims = dims;
CustomDims = customDims;
Method = method;
VectorElements = vectorElements;
ExpectedSize = expectedSize;
}
public void AnyDimensionCanBeZero()
{
var rank1Dims = new TensorDimensions(0);
Assert.Equal(0, rank1Dims.ElementCount);
var rankNDims = new TensorDimensions(3, 0, 5);
Assert.Equal(3, rankNDims[0]);
Assert.Equal(0, rankNDims.ElementCount);
}
public TensorDimensions Apply(TensorDimensions originalDims)
{
var dimsOrError = ComputeDimensions(originalDims.ElementCount);
if (dimsOrError.Item1 == null)
{
throw dimsOrError.Item2;
}
return(dimsOrError.Item1);
}
public void PrintIndicatesMismatchedDimsAndSize()
{
var dims = new TensorDimensions(3, 3) { Size = 4 };
Assert.Equal("3×3 (!)", dims.Print());
}
public void ParseKeepsDimensionsOfSizeOne()
{
var dims = new TensorDimensions();
dims.Parse("1, 5, *, 1, 1");
Assert.Equal(5, dims.Count);
Assert.Equal(1, dims[0]);
Assert.Equal(5, dims[1]);
Assert.Equal(1, dims[4]);
Assert.Equal("", dims.LastSetWarning);
}
public void ParseDoesNotAutoAddDimWhenSizeMatches()
{
var dims = new TensorDimensions() { Size = 2*2*2 };
dims.Parse("2, 2, 2");
Assert.Equal(3, dims.Count);
Assert.Equal(2, dims[0]);
Assert.Equal(2, dims[1]);
}
public void HashCodeIsCachedProperly()
{
var dims = new TensorDimensions(3, 5, 7);
int hashCode = dims.GetHashCode();
Assert.Equal(hashCode, dims.GetHashCode());
}
private static MyMemoryBlock<float> GetMemBlockWithCustomDims(string dimensionsSource)
{
var customDims = new TensorDimensions();
customDims.Parse(dimensionsSource);
return new MyMemoryBlock<float> { Dims = customDims };
}
public void PrintsOneOne()
{
var dims = new TensorDimensions(1, 1);
Assert.Equal("1 (!)", dims.Print(hideTrailingOnes: true));
}
public bool Equals(TensorDimensions dimensionsHint)
{
return base.Equals(dimensionsHint);
}
public ColumnHintTestData(TensorDimensions initialDims, int columnHint, TensorDimensions expectedDims, string comment)
{
InitialDims = initialDims;
ColumnHint = columnHint;
ExpectedDims = expectedDims;
Comment = comment;
}
private static MyAbstractMemoryBlock GetMemBlock(TensorDimensions dims)
{
return new MyMemoryBlock<float> { Dims = dims };
}
public void TranspositionTests(TensorDimensions initial, TensorDimensions expected)
{
Assert.True(initial.Transpose().Equals(expected));
}
public void PrintsEmptyDims()
{
var dims = new TensorDimensions();
Assert.Equal("0", dims.Print());
}
public void PrintsComputedTrailingOne()
{
var dims = new TensorDimensions(4, 2, -1) { Size = 8 };
Assert.Equal("4×2×1", dims.Print(hideTrailingOnes: true));
}
public void DimensionsOfSizeOneAreAllowed()
{
var dims = new TensorDimensions();
dims.Set(new []{ 5, 1, 1 });
}
public void PrintsLeadingOrMiddleOnes()
{
var dims = new TensorDimensions(1, 1, -1, 5, 1, 2, 1);
Assert.Equal("1×1×?×5×1×2", dims.Print(hideTrailingOnes: true));
}
public void EmptyDimensionsCanBeComputed()
{
var dims = new TensorDimensions();
Assert.False(dims.CanBeComputed);
dims.Size = 4;
Assert.True(dims.CanBeComputed);
Assert.Equal(4, dims[0]);
}
public void CanBeComputedEvaluatesToFalse()
{
var dims = new TensorDimensions(3, 4, -1, 5) { Size = 37 };
Assert.False(dims.CanBeComputed);
}
public bool TryToApply(TensorDimensions originalDims, out TensorDimensions customDims)
{
TensorDimensions adjustedDims = ComputeDimensions(originalDims.ElementCount);
customDims = adjustedDims ?? originalDims;
return (adjustedDims != null);
}
public TensorDimensions TryToApply(TensorDimensions originalDims)
{
return(TryComputeDimensions(originalDims.ElementCount) ?? originalDims);
}
public void ParseAutoAddsLeadingDim()
{
var dims = new TensorDimensions();
dims.Parse("2, 2, 2");
Assert.Equal(4, dims.Count);
Assert.Equal(-1, dims[0]);
Assert.Equal(2, dims[1]);
}
private Size ComputeTiledTextureSize(TensorDimensions dims, MyAbstractMemoryBlock target)
{
int effectivePixelsDisplayed;
if (Method == RenderingMethod.RGB)
{
// check if:
// memory block has 3 chanels
// chanels are divisible by requested TileWidth and TileHeight
// TileWidth and TileHeight are not too big
if (
dims.ElementCount % 3 != 0 ||
dims.ElementCount / TileWidth / TileHeight % 3 != 0 ||
dims.ElementCount / TileWidth / TileHeight / 3 == 0)
{
MyLog.WARNING.WriteLine("Memory block '{0}: {1}' observer: {2}", Target.Owner.Name, Target.Name,
"RGB rendering, but Memory block.count and TileWidth and TileHeight values incompatible with the RGB format!" +
" Swtiching to RedGreenScale. Use correct CustomDimensions");
Method = RenderingMethod.RedGreenScale;
effectivePixelsDisplayed = dims.ElementCount;
}
else
{
effectivePixelsDisplayed = (int)Math.Ceiling((decimal)((float)dims.ElementCount / (float)3));
}
}
else
{
effectivePixelsDisplayed = dims.ElementCount;
}
if (TileWidth * TileHeight * TilesInRow > effectivePixelsDisplayed)
{
TilesInRow = effectivePixelsDisplayed / (TileWidth * TileHeight);
String message = " (Parsed from " + (UseCustomDimensions ? "CustomDimensions)" : "MemoryBlock.Dims)");
MyLog.WARNING.WriteLine("Memory block '{0}: {1}' observer: {2}", Target.Owner.Name, Target.Name,
"TilesInRow too big, adjusting to the max. value " + TilesInRow + "\n\t\t..for TileWidth=" + TileWidth + ", TileHeight=" + TileHeight + message);
}
m_noBlocks = effectivePixelsDisplayed / (TileWidth * TileHeight);
TilesInColumn = (int)Math.Ceiling((decimal)((float)m_noBlocks / (float)TilesInRow));
return new Size(TileWidth * TilesInRow, TilesInColumn * TileHeight);
}
public void ElementCountIsCachedProperly()
{
var dims = new TensorDimensions(3, 5, 7);
Assert.Equal(3*5*7, dims.ElementCount);
Assert.Equal(3*5*7, dims.ElementCount);
}
public void DoesNotPrintTrailingOnes()
{
var dims = new TensorDimensions(5, 1, 1) { Size = 5 };
Assert.Equal("5", dims.Print(hideTrailingOnes: true));
}
// TODO(Premek): Report warnings using a logger interface.
internal static Size ComputeCustomTextureSize(TensorDimensions dims, CustomDimensionsHint customDims,
RenderingMethod method, int vectorElements, out string warning)
{
warning = "";
if (dims.IsEmpty)
return Size.Empty;
bool isDivisible;
string divisorName = (method == RenderingMethod.RGB) ? "3 (RGB channel count)" : "vector element count";
bool isRowVector = (dims.Rank == 1) || (dims.Rank == 2 && dims[1] == 1);
bool isColumnVector = !isRowVector && (dims.Rank == 2) && (dims[0] == 1);
TensorDimensions adjustedDims;
bool didApplyCustomDims = customDims.TryToApply(dims, out adjustedDims);
if (!customDims.IsEmpty && !didApplyCustomDims)
warning = "Could not apply custom dimensions (the element count must match the original).";
if (!didApplyCustomDims && (isRowVector || isColumnVector))
{
return ComputeTextureSizeForVector(dims.ElementCount, isRowVector, method, vectorElements, divisorName,
ref warning);
}
int shrinkedLastDim = ShrinkSizeForRenderingMethod(adjustedDims[adjustedDims.Rank - 1], method,
vectorElements, out isDivisible);
if (!isDivisible || (shrinkedLastDim == 0))
{
if (string.IsNullOrEmpty(warning))
warning = string.Format("The last dimension is {0} {1}. Ignoring dimensions.",
(!isDivisible) ? "not divisible by" : "smaller than", divisorName);
return ComputeTextureSize(
ShrinkSizeForRenderingMethod(dims.ElementCount, method, vectorElements, out isDivisible));
}
// Squash all dimensions except the first one together.
// TODO(Premek): Decide according to actual sizes of the dimensions.
int squashedOtherDims = shrinkedLastDim;
for (int i = 1; i < adjustedDims.Rank - 1; i++)
squashedOtherDims *= adjustedDims[i];
return new Size(adjustedDims[0], squashedOtherDims);
}
public bool Equals(TensorDimensions dimensionsHint)
{
return(base.Equals(dimensionsHint));
}
public TensorDimensions TryToApply(TensorDimensions originalDims)
{
return ComputeDimensions(originalDims.ElementCount) ?? originalDims;
}
