public void TestComplex2Complex2Complex3D_2()
{
_gpu.CopyToDevice(_hostInputCplx, _devInputCplx);
ComplexD[, ,] devInputCplx3D = _gpu.Cast(_devInputCplx, NX, NY, NZ);
ComplexD[, ,] devInterCplx3D = _gpu.Cast(_devInterCplx, NX, NY, NZ);
ComplexD[, ,] devOutputCplx3D = _gpu.Cast(_devOutputCplx, NX, NY, NZ);
FFTPlan3D planFwd = _fft.Plan3D(eFFTType.Complex2Complex, eDataType.Double, NX, NY, NZ, BATCH);
planFwd.Execute(devInputCplx3D, devInterCplx3D);
FFTPlan3D planRev = _fft.Plan3D(eFFTType.Complex2Complex, eDataType.Double, NX, NY, NZ, BATCH);
planRev.Execute(devInterCplx3D, devOutputCplx3D, true);
_devOutputCplx = _gpu.Cast(devOutputCplx3D, NX * NY * NZ * BATCH);
_gpu.CopyFromDevice(_devOutputCplx, _hostOutputCplx);
for (int i = 0; i < N * BATCH; i++)
{
Assert.AreEqual(_hostInputCplx[i].x, _hostOutputCplx[i].x / (double)N, 1, "Index {0} (x)", i);
Assert.AreEqual(_hostInputCplx[i].y, _hostOutputCplx[i].y / (double)N, 1, "Index {0} (y)", i);
}
}
public void TestMAXInVectorWhole()
{
CreateRandomData(_hostInput);
DebugBuffer(_hostInput);
_gpu.CopyToDevice(_hostInput, _devPtr);
float[] castDevPtr = _gpu.Cast(_devPtr, ciTOTAL);
int index = _blas.IAMAX(castDevPtr);
var list = _hostInput.Cast <float>().ToList();
float max = list.Max();
Debug.WriteLine(index);
Debug.WriteLine(max);
Assert.AreEqual(max, list[index - 1]); // 1-indexed
}
public void Test_doubleVectorOffset()
{
int[] a = new int[N];
int[] c = new int[N];
for (int i = 0; i < N; i++)
{
a[i] = i;
}
int[] dev_a = _gpu.CopyToDevice(a);
int[] dev_a_offset = _gpu.Cast(N / 2, dev_a, N / 2);
_gpu.Launch(N / 2, 1, "doubleVectorOffset", dev_a_offset);
_gpu.CopyFromDevice(dev_a_offset, c);
for (int i = N / 2; i < N; i++)
{
Assert.AreEqual(i * 2, c[i - N / 2]);
}
_gpu.Free(dev_a);
}
public void Test_cast_byte()
{
if (_gpu is EmulatedGPU || _gpu is OpenCLDevice)
{
Console.WriteLine("Emulated not supporting cast with offset, so skip.");
return;
}
_gpubyteBufferIn = _gpu.Allocate(_byteBufferIn);
_gpu.CopyToDevice(_byteBufferIn, _gpubyteBufferIn);
byte[] offsetArray = _gpu.Cast(N / 16, _gpubyteBufferIn, N / 2);
_gpu.CopyFromDevice(offsetArray, 0, _byteBufferOut, 0, N / 2);
Assert.IsTrue(Compare(_byteBufferIn, _byteBufferOut, N / 16, 0, N / 2));
ClearOutputsAndGPU();
}
public void TestReal2Complex2Real2D_2()
{
_gpu.CopyToDevice(_hostInput, _devInput);
float[,] devInput2D = _gpu.Cast(_devInput, W, H);
ComplexF[,] devInterCplx2D = _gpu.Cast(_devInterCplx, W, H);
FFTPlan2D planFwd = _fft.Plan2D(eFFTType.Real2Complex, eDataType.Single, W, H, 1);
planFwd.Execute(devInput2D, devInterCplx2D);
FFTPlan2D planRev = _fft.Plan2D(eFFTType.Complex2Real, eDataType.Single, W, H, 1);
float[,] devOutput2D = _gpu.Cast(_devOutput, W, H);
planRev.Execute(devInterCplx2D, devOutput2D);
_gpu.CopyFromDevice(_devOutput, _hostOutput);
for (int i = 0; i < N * 1; i++)
{
Assert.AreEqual(_hostInput[i], _hostOutput[i] / (float)N, 0.0001, "Index {0}", i);
}
}
