public void Multiply_Scalar()
{
// arrange
var targetData = new int[1];
var src1Data = new int[1];
var src2Data = new int[1];
var target = new DataAndLayout <int>(targetData, new FastAccess(new Layout(new int[] { }, 0, new int[] { })));
var src1 = new DataAndLayout <int>(src1Data, new FastAccess(new Layout(new int[] { }, 0, new int[] { })));
var src2 = new DataAndLayout <int>(src2Data, new FastAccess(new Layout(new int[] { }, 0, new int[] { })));
const int CopyPattern1 = 4;
src1Data[0] = CopyPattern1;
const int CopyPattern2 = 5;
src2Data[0] = CopyPattern2;
// action
ScalarOps.Multiply(target, src1, src2);
// assert
const int ExpectedValue = 20;
Assert.AreEqual(ExpectedValue, targetData[0]);
}
public void CanUse_ScalarTarget_ReturnFalse()
{
// arrange
var target = new DataAndLayout <int>(new int[1], new FastAccess(new Layout(new int[] { }, 0, new int[] { })));
// action
var canUse = VectorOps.CanUse(target);
// assert
Assert.IsFalse(canUse);
}
public void CanUse_GoodTargetOnly_ReturnTrue()
{
// arrange
var target = new DataAndLayout <int>(new int[10], new FastAccess(new Layout(new int[] { 10 }, 0, new int[] { 1 })));
// action
var canUse = VectorOps.CanUse(target);
// assert
Assert.IsTrue(canUse);
}
public void Convert_InvalidConvert_ThrowException()
{
var targetData = new string[4];
var srcData = new[] { 4, 2, 7, 1 };
var target = new DataAndLayout <string>(targetData, new FastAccess(new Layout(new int[] { 4 }, 0, new int[] { 1 })));
var source = new DataAndLayout <int>(srcData, new FastAccess(new Layout(new int[] { 4 }, 0, new int[] { 1 })));
// action
ScalarOps.Convert(target, source);
}
public void CanUse_UnSupportedType_ReturnFalse()
{
// arrange
var data = new UnSupportedTypeForUnitTestOnly[1];
var target = new DataAndLayout <UnSupportedTypeForUnitTestOnly>(data, new FastAccess(new Layout(new int[] { }, 0, new int[] { })));
// action
var canUse = VectorOps.CanUse(target);
// assert
Assert.IsFalse(canUse);
}
public void CanUse_TargetIsNotContinuous_ReturnFalse()
{
// arrange
const int NotContinuousStride = 2;
var target = new DataAndLayout <int>(new int[20], new FastAccess(new Layout(new int[] { 10 }, 0, new int[] { NotContinuousStride })));
// action
var canUse = VectorOps.CanUse(target);
// assert
Assert.IsFalse(canUse);
}
public void CanUse_CanUseBothSrc1AndSrc2_ReturnTrue()
{
// arrange
var target = new DataAndLayout <int>(new int[10], new FastAccess(new Layout(new int[] { 10 }, 0, new int[] { 1 })));
var src1 = new DataAndLayout <int>(new int[10], new FastAccess(new Layout(new int[] { 10 }, 0, new int[] { 1 })));
var src2 = new DataAndLayout <int>(new int[10], new FastAccess(new Layout(new int[] { 10 }, 0, new int[] { 1 })));
// action
var canUse = VectorOps.CanUse(target, src1, src2);
// assert
Assert.IsTrue(canUse);
}
public void Fill_Scalar()
{
// arrange
var data = new int[1];
var scalar = new DataAndLayout <int>(data, new FastAccess(new Layout(new int[] { }, 0, new int[] { })));
// action
const int FillPattern = 999;
ScalarOps.Fill(FillPattern, scalar);
// assert
Assert.IsTrue(data.All(d => d == FillPattern));
}
public void CanUseSrc_NotContinuousStride_ReturnFalse()
{
// arrange
const int BufferSize = 6;
const int NumDim = 3;
var data = new int[BufferSize];
var src = new DataAndLayout <int>(data, new FastAccess(new Layout(new int[] { 1, 2, 3 }, 0, new int[] { 6, 3, 2 })));
// action
var canUse = VectorOps.CanUseSrc(NumDim, src);
// assert
Assert.IsFalse(canUse);
}
public void CanUseSrc_NoStride_ReturnTrue()
{
// arrange
const int BufferSize = 1;
const int NumDim = 1;
var data = new int[BufferSize];
var src = new DataAndLayout <int>(data, new FastAccess(new Layout(new int[] { 1 }, 0, new int[] { 0 })));
// action
var canUse = VectorOps.CanUseSrc(NumDim, src);
// assert
Assert.IsTrue(canUse);
}
public void Fill_Vector2D()
{
// arrange
var data = new int[24];
var target = new DataAndLayout <int>(data, new FastAccess(new Layout(new int[] { 2, 3, 4 }, 0, new int[] { 12, 4, 1 })));
const int FillPattern = 999;
// action
ScalarOps.Fill(FillPattern, target);
// assert
Assert.IsTrue(data.All(d => d == FillPattern));
}
public void TrueIndices()
{
// arrange
var targetData = new int[4];
var srcData = new bool[] { false, true, false, true };
var target = new DataAndLayout <int>(targetData, new FastAccess(new Layout(new int[] { 4 }, 0, new int[] { 1 })));
var source = new DataAndLayout <bool>(srcData, new FastAccess(new Layout(new int[] { 4 }, 0, new int[] { 1 })));
// action
ScalarOps.TrueIndices(target, source);
// assert
CollectionAssert.AreEqual(new[] { 1, 3, 1, 3 }, targetData);
}
public void FindLastAxis_Notfound()
{
// arrange
var targetData = new int[4];
var srcData = new[] { 4, 2, 7, 1 };
var target = new DataAndLayout <int>(targetData, new FastAccess(new Layout(new int[] { 4 }, 0, new int[] { 1 })));
var src = new DataAndLayout <int>(srcData, new FastAccess(new Layout(new int[] { 4 }, 0, new int[] { 1 })));
// action
ScalarOps.FindLastAxis(9, target, src);
// assert
Assert.AreEqual(SpecialIdx.NotFound, targetData[0]);
}
public void CanUse_CanNotUseSrc1Only_ReturnFalse()
{
// arrange
var target = new DataAndLayout <int>(new int[10], new FastAccess(new Layout(new int[] { 10 }, 0, new int[] { 1 })));
var src2 = new DataAndLayout <int>(new int[10], new FastAccess(new Layout(new int[] { 10 }, 0, new int[] { 1 })));
const int NotContinuousStride = 2;
var src1 = new DataAndLayout <int>(new int[20], new FastAccess(new Layout(new int[] { 10 }, 0, new int[] { NotContinuousStride })));
// action
var canUse = VectorOps.CanUse(target, src1, src2);
// assert
Assert.IsFalse(canUse);
}
public void ArgMaxLastAxis()
{
// arrange
var targetData = new int[4];
var srcData = new[] { 4, 2, 7, 1 };
var target = new DataAndLayout <int>(targetData, new FastAccess(new Layout(new int[] { 4 }, 0, new int[] { 1 })));
var src = new DataAndLayout <int>(srcData, new FastAccess(new Layout(new int[] { 4 }, 0, new int[] { 1 })));
// action
ScalarOps.ArgMaxLastAxis(target, src);
// assert
Assert.AreEqual(2, targetData[0]);
}
public void CountTrueLastAxis()
{
// arrange
var targetData = new int[1];
var srcData = new[] { false, false, true, true };
var target = new DataAndLayout <int>(targetData, new FastAccess(new Layout(new int[] { 1 }, 0, new int[] { 1 })));
var src = new DataAndLayout <bool>(srcData, new FastAccess(new Layout(new int[] { 4 }, 0, new int[] { 1 })));
// action
ScalarOps.CountTrueLastAxis(target, src);
// assert
Assert.AreEqual(2, targetData[0]);
}
public void FillIncrementing()
{
// arrange
const int BufferSize = 10;
var data = new int[BufferSize];
var target = new DataAndLayout <int>(data, new FastAccess(new Layout(new int[] { BufferSize }, 0, new int[] { 1 })));
// action
ScalarOps.FillIncrementing(0, 2, target);
// assert
var expecedData = Enumerable.Range(0, BufferSize).Select(n => n * 2).ToArray();
Assert.IsTrue(Enumerable.SequenceEqual(expecedData, data));
}
public void Fill_Vector1D()
{
// arrange
const int BufferSize = 10;
var data = new int[BufferSize];
var target = new DataAndLayout <int>(data, new FastAccess(new Layout(new int[] { BufferSize }, 0, new int[] { 1 })));
const int FillPattern = 999;
// action
ScalarOps.Fill(FillPattern, target);
// assert
Assert.IsTrue(data.All(d => d == FillPattern));
}
public void AnyLastAxis_NotAllFalse()
{
// arrange
const int NumElements = 4;
var targetData = new bool[NumElements];
var srcData = new[] { false, false, true, true };
var target = new DataAndLayout <bool>(targetData, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
var src = new DataAndLayout <bool>(srcData, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
// action
ScalarOps.AnyLastAxis(target, src);
// assert
CollectionAssert.AreEqual(new[] { true, false, false, false }, targetData);
}
public void ProductLastAxis()
{
// arrange
const int NumElements = 6;
var targetData = new double[NumElements];
var srcData = new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
var target = new DataAndLayout <double>(targetData, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
var src = new DataAndLayout <double>(srcData, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
// action
ScalarOps.ProductLastAxis(target, src);
// assert
Assert.AreEqual(720.0, targetData[0]);
}
public void MinLastAxis()
{
// arrange
const int NumElements = 6;
var targetData = new double[NumElements];
var srcData = new[] { -1.0, -0.6, -0.2, 0.2, 0.6, 1.0 };
var target = new DataAndLayout <double>(targetData, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
var src = new DataAndLayout <double>(srcData, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
// action
ScalarOps.MinLastAxis(target, src);
// assert
Assert.AreEqual(-1, targetData[0]);
}
public void Truncate()
{
// arrange
const int NumElements = 6;
var targetData = new double[NumElements];
var srcData = new[] { -1.0, -0.6, -0.2, 0.2, 0.6, 1.0 };
var target = new DataAndLayout <double>(targetData, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
var src = new DataAndLayout <double>(srcData, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
// action
ScalarOps.Truncate(target, src);
// assert
CollectionAssert.AreEqual(new[] { -1.0, 0.0, 0.0, 0.0, 0.0, 1.0 }, targetData);
}
public void Sqrt()
{
// arrange
const int NumElements = 3;
var targetData = new double[NumElements];
var srcData = new[] { 1.0, 4.0, 16.0 };
var target = new DataAndLayout <double>(targetData, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
var src = new DataAndLayout <double>(srcData, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
// action
ScalarOps.Sqrt(target, src);
// assert
CollectionAssert.AreEqual(new[] { 1.0, 2.0, 4.0 }, targetData);
}
public void Convert()
{
// arrange
var targetData = new double[4];
var srcData = new[] { 4, 2, 7, 1 };
var target = new DataAndLayout <double>(targetData, new FastAccess(new Layout(new int[] { 4 }, 0, new int[] { 1 })));
var source = new DataAndLayout <int>(srcData, new FastAccess(new Layout(new int[] { 4 }, 0, new int[] { 1 })));
// action
ScalarOps.Convert(target, source);
// assert
Assert.IsInstanceOfType(targetData, typeof(double[]));
CollectionAssert.AreEqual(new[] { 4.0, 2.0, 7.0, 1.0 }, targetData);
}
public void Copy_Vector2D()
{
// arrange
const int BufferSize = 24;
var targetData = new int[BufferSize];
var srcData = Enumerable.Range(0, BufferSize).ToArray();
var target = new DataAndLayout <int>(targetData, new FastAccess(new Layout(new int[] { 2, 3, 4 }, 0, new int[] { 12, 4, 1 })));
var src = new DataAndLayout <int>(srcData, new FastAccess(new Layout(new int[] { 2, 3, 4 }, 0, new int[] { 12, 4, 1 })));
// action
ScalarOps.Copy(target, src);
// assert
Assert.IsTrue(Enumerable.SequenceEqual(targetData, srcData));
}
public void Abs()
{
// arrange
var bufferSize = 10;
var targetData = new int[bufferSize];
var srcData = Enumerable.Range(-1 * bufferSize / 2, bufferSize).ToArray();
var target = new DataAndLayout <int>(targetData, new FastAccess(new Layout(new int[] { bufferSize }, 0, new int[] { 1 })));
var src = new DataAndLayout <int>(srcData, new FastAccess(new Layout(new int[] { bufferSize }, 0, new int[] { 1 })));
// action
ScalarOps.Abs(target, src);
// assert
var allPositive = target.Data.All(v => v >= 0);
Assert.IsTrue(allPositive);
}
public void Xor()
{
// arrange
const int NumElements = 4;
var targetData = new bool[NumElements];
var src1Data = new[] { false, false, true, true };
var src2Data = new[] { false, true, false, true };
var target = new DataAndLayout <bool>(targetData, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
var src1 = new DataAndLayout <bool>(src1Data, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
var src2 = new DataAndLayout <bool>(src2Data, new FastAccess(new Layout(new int[] { NumElements }, 0, new int[] { 1 })));
// action
ScalarOps.Xor(target, src1, src2);
// assert
CollectionAssert.AreEqual(new[] { false, true, true, false }, targetData);
}
public void Fill()
{
// arrange
var vectorCount = Vector <int> .Count;
// Itentionally break the alignment for the Vector operation to test more code.
var bufferSize = 10 + (vectorCount / 2);
var data = new int[bufferSize];
var target = new DataAndLayout <int>(data, new FastAccess(new Layout(new int[] { bufferSize }, 0, new int[] { 1 })));
const int FillPattern = 999;
// action
VectorOps.Fill(FillPattern, target);
// assert
Assert.IsTrue(data.All(d => d == FillPattern));
}
public void Copy_Scalar()
{
// arrange
var targetData = new int[1];
var srcData = new int[1];
var target = new DataAndLayout <int>(targetData, new FastAccess(new Layout(new int[] { }, 0, new int[] { })));
var src = new DataAndLayout <int>(srcData, new FastAccess(new Layout(new int[] { }, 0, new int[] { })));
const int CopyPattern = 999;
srcData[0] = CopyPattern;
// action
ScalarOps.Copy(target, src);
// assert
Assert.AreEqual(CopyPattern, targetData[0]);
}
public void Atan()
{
// arrange
var targetData = new double[3];
var srcData = new double[] { -1.0, 0, 1.0 };
var target = new DataAndLayout <double>(targetData, new FastAccess(new Layout(new int[] { 3 }, 0, new int[] { 1 })));
var src = new DataAndLayout <double>(srcData, new FastAccess(new Layout(new int[] { 3 }, 0, new int[] { 1 })));
// action
ScalarOps.Atan(target, src);
// assert
const double Epsilon = 1e-8;
Assert.IsTrue(Math.Abs(targetData[0] - (-Math.PI / 4.0)) < Epsilon);
Assert.IsTrue(Math.Abs(targetData[1] - 0.0) < Epsilon);
Assert.IsTrue(Math.Abs(targetData[2] - (Math.PI / 4.0)) < Epsilon);
}
