예제 #1
0
 private static extern CUBLASStatusv2 cublasCrot_v2(cublasHandle handle, int n, IntPtr x, int incx, IntPtr y, int incy, ref float c, ref ComplexF s);
예제 #2
0
 public CUBLASStatusv2 cublasCaxpy(cublasHandle handle, int n, ref ComplexF alpha, IntPtr x, int incx, IntPtr y, int incy)
 {
     return cublasCaxpy_v2(handle, n, ref alpha, x, incx, y, incy);
 }
예제 #3
0
 /// <summary>
 /// Subtracts value y from value x.
 /// </summary>
 /// <param name="x">Value one.</param>
 /// <param name="y">Value to be subtracted.</param>
 /// <returns>New value.</returns>
 public static ComplexF Subtract(ComplexF x, ComplexF y)
 {
     x.x = x.x - y.x;
     x.y = x.y - y.y;
     return(x);
 }
예제 #4
0
 private static extern CUBLASStatusv2 cublasCaxpy_v2(cublasHandle handle, int n, ref ComplexF alpha, IntPtr x, int incx, IntPtr y, int incy);
예제 #5
0
 /// <summary>
 /// ROTGs the specified a.
 /// </summary>
 /// <param name="a">A.</param>
 /// <param name="b">The b.</param>
 /// <param name="c">The c.</param>
 /// <param name="s">The s.</param>
 public abstract void ROTG(ComplexF[] a, ComplexF[] b, float[] c, ComplexF[] s);
예제 #6
0
 /// <summary>
 /// Conjugates the specified value.
 /// </summary>
 /// <param name="x">The value.</param>
 /// <returns>Conjugated value.</returns>
 public static ComplexF Conj(ComplexF x)
 {
     return(new ComplexF(x.x, -1 * x.y));
 }
예제 #7
0
 /// <summary>
 /// Adds value y to value x.
 /// </summary>
 /// <param name="x">Value one.</param>
 /// <param name="y">Value to be added.</param>
 /// <returns>New value.</returns>
 public static ComplexF Add(ComplexF x, ComplexF y)
 {
     x.x = x.x + y.x;
     x.y = x.y + y.y;
     return x;
 }
예제 #8
0
 /// <summary>
 /// ROTs the specified vectorx.
 /// </summary>
 /// <param name="vectorx">The vectorx.</param>
 /// <param name="vectory">The vectory.</param>
 /// <param name="c">The c.</param>
 /// <param name="s">The s.</param>
 /// <param name="n">The n.</param>
 /// <param name="rowx">The rowx.</param>
 /// <param name="incx">The incx.</param>
 /// <param name="rowy">The rowy.</param>
 /// <param name="incy">The incy.</param>
 public void ROT(ComplexF[] vectorx, ComplexF[] vectory, float c, float s, int n = 0, int rowx = 0, int incx = 1, int rowy = 0, int incy = 1)
 {
     ROT(vectorx, vectory, new[] { c }, new[] { s }, n, rowx, incx, rowy, incy);
 }
예제 #9
0
 /// <summary>
 /// Gets the absolute of the specified value.
 /// </summary>
 /// <param name="x">The value.</param>
 /// <returns>Absolute.</returns>
 public static float Abs(ComplexF x)
 {
     float a = x.x;
     float b = x.y;
     float v, w, t;
     a = Math.Abs(a);
     b = Math.Abs(b);
     if (a > b)
     {
         v = a;
         w = b;
     }
     else
     {
         v = b;
         w = a;
     }
     t = w / v;
     t = 1.0f + t * t;
     t = v * GMath.Sqrt(t);
     if ((v == 0.0f) || (v > 3.402823466e38f) || (w > 3.402823466e38f))
     {
         t = v + w;
     }
     return t;
 }
예제 #10
0
 /// <summary>
 /// Conjugates the specified value.
 /// </summary>
 /// <param name="x">The value.</param>
 /// <returns>Conjugated value.</returns>
 public static ComplexF Conj(ComplexF x)
 {
     return new ComplexF(x.x, -1 * x.y);
 }
예제 #11
0
 /// <summary>
 /// Divides value x by y.
 /// </summary>
 /// <param name="x">Value one.</param>
 /// <param name="y">Value two.</param>
 /// <returns>New value.</returns>
 public static ComplexF Divide(ComplexF x, ComplexF y)
 {
     float s = Math.Abs(y.x) + Math.Abs(y.y); 
     float oos = 1.0f / s;
     float ars = x.x * oos;
     float ais = x.y * oos;
     float brs = y.x * oos;
     float bis = y.y * oos;
     s = (brs * brs) + (bis * bis);
     oos = 1.0f / s;
     ComplexF quot = new ComplexF(((ars * brs) + (ais * bis)) * oos,
                                 ((ais * brs) - (ars * bis)) * oos);
     return quot;
 }
예제 #12
0
        public static void Execute()
        {
            CudafyModule km = CudafyTranslator.Cudafy();

            GPGPU gpu = CudafyHost.GetDevice(CudafyModes.Target);
            gpu.LoadModule(km);

            // 2D
            Console.WriteLine("kernel");
            ComplexF[,] host_A = new ComplexF[XSIZE, YSIZE];
            ComplexF[,] host_B = new ComplexF[XSIZE, YSIZE];
            ComplexF[,] host_C = new ComplexF[XSIZE, YSIZE];
            int i = 0;
            for (int x = 0; x < XSIZE; x++)
                for (int y = 0; y < YSIZE; y++)
                {
                    host_A[x, y] = new ComplexF(i, i);
                    host_B[x, y] = new ComplexF(2, 0); 
                    i++;
                }
            ComplexF[,] dev_A = gpu.CopyToDevice(host_A);
            ComplexF[,] dev_B = gpu.CopyToDevice(host_B);
            ComplexF[,] dev_C = gpu.Allocate<ComplexF>(XSIZE, YSIZE);

            Console.WriteLine("complexAdd");
            gpu.Launch(XSIZE, 1, "complexAdd", dev_A, dev_B, dev_C);
            gpu.CopyFromDevice(dev_C, host_C);
            i = 0;
            bool pass = true;
            for (int x = 0; x < XSIZE; x++)
            {
                for (int y = 0; y < YSIZE && pass; y++)
                {
                    ComplexF expected = ComplexF.Add(host_A[x, y], host_B[x, y]);
                    pass = host_C[x, y].x == expected.x && host_C[x, y].y == expected.y;
                }
            }
            Console.WriteLine(pass ? "Pass" : "Fail");

            Console.WriteLine("complexSub");
            gpu.Launch(XSIZE, 1, "complexSub", dev_A, dev_B, dev_C);
            gpu.CopyFromDevice(dev_C, host_C);
            i = 0;
            pass = true;
            for (int x = 0; x < XSIZE; x++)
            {
                for (int y = 0; y < YSIZE && pass; y++)
                {
                    ComplexF expected = ComplexF.Subtract(host_A[x, y], host_B[x, y]);
                    pass = host_C[x, y].x == expected.x && host_C[x, y].y == expected.y;
                }
            }
            Console.WriteLine(pass ? "Pass" : "Fail");

            Console.WriteLine("complexMpy");
            gpu.Launch(XSIZE, 1, "complexMpy", dev_A, dev_B, dev_C);
            gpu.CopyFromDevice(dev_C, host_C);
            i = 0;
            pass = true;
            for (int x = 0; x < XSIZE; x++)
            {
                for (int y = 0; y < YSIZE && pass; y++)
                {
                    ComplexF expected = ComplexF.Multiply(host_A[x, y], host_B[x, y]);
                    //Console.WriteLine("{0} {1} : {2} {3}", host_C[x, y].R, host_C[x, y].I, expected.R, expected.I);
                    pass = Verify(host_C[x, y], expected, 1e-14F); 
                    i++;
                }
            }
            Console.WriteLine(pass ? "Pass" : "Fail");

            Console.WriteLine("complexDiv");
            gpu.Launch(XSIZE, 1, "complexDiv", dev_A, dev_B, dev_C);
            gpu.CopyFromDevice(dev_C, host_C);
            i = 0;
            pass = true;
            for (int x = 0; x < XSIZE; x++)
            {
                for (int y = 0; y < YSIZE && pass; y++)
                {
                    ComplexF expected = ComplexF.Divide(host_A[x, y], host_B[x, y]);
                    //Console.WriteLine("{0} {1} : {2} {3}", host_C[x, y].R, host_C[x, y].I, expected.R, expected.I);
                    if (i > 0)
                        pass = Verify(host_C[x, y], expected, 1e-13F);
                    i++;
                }
            }
            Console.WriteLine(pass ? "Pass" : "Fail");

            Console.WriteLine("complexAbs");
            gpu.Launch(XSIZE, 1, "complexAbs", dev_A, dev_C);
            gpu.CopyFromDevice(dev_C, host_C);
            i = 0;
            pass = true;
            for (int x = 0; x < XSIZE; x++)
            {
                for (int y = 0; y < YSIZE && pass; y++)
                {
                    float expected = ComplexF.Abs(host_A[x, y]);
                    pass = Verify(host_C[x, y].x, expected, 1e-2F);
                    //Console.WriteLine("{0} {1} : {2}", host_C[x, y].x, host_C[x, y].y, expected);
                    i++;
                }
            }
            Console.WriteLine(pass ? "Pass" : "Fail");

            gpu.FreeAll();
        }
예제 #13
0
 public static void complexAbs(GThread thread, ComplexF[,] a, ComplexF[,] c)
 {
     int x = thread.blockIdx.x;
     int y = 0;
     float j = 1.0F;
     float k = 2.0F;
     ComplexF cf = new ComplexF(3 + j, 7 + k);
     while (y < YSIZE)
     {
         c[x, y].x = ComplexF.Abs(a[x, y]);
         c[x, y].y = cf.y;// 0.0F;
         y++;
     }
 }
예제 #14
0
 public CUBLASStatusv2 cublasCrot(cublasHandle handle, int n, IntPtr x, int incx, IntPtr y, int incy, ref float c, ref ComplexF s)
 {
     return cublasCrot_v2(handle, n, x, incx, y, incy, ref c, ref s);
 }
예제 #15
0
 /// <summary>
 /// Subtracts value y from value x.
 /// </summary>
 /// <param name="x">Value one.</param>
 /// <param name="y">Value to be subtracted.</param>
 /// <returns>New value.</returns>
 public static ComplexF Subtract(ComplexF x, ComplexF y)
 {
     x.x = x.x - y.x;
     x.y = x.y - y.y;
     return x;
 }
예제 #16
0
 public static void complexDiv(GThread thread, ComplexF[,] a, ComplexF[,] b, ComplexF[,] c)
 {
     int x = thread.blockIdx.x;
     int y = 0;
     while (y < YSIZE)
     {
         c[x, y] = ComplexF.Divide(a[x, y], b[x, y]);
         y++;
     }
 }
예제 #17
0
 /// <summary>
 /// Multiplies value x and y.
 /// </summary>
 /// <param name="x">Value one.</param>
 /// <param name="y">Value two.</param>
 /// <returns>New value.</returns>
 public static ComplexF Multiply(ComplexF x, ComplexF y)
 {
     ComplexF c = new ComplexF();
     c.x = x.x * y.x - x.y * y.y;
     c.y = x.x * y.y + x.y * y.x;
     return c;
 }
예제 #18
0
 /// <summary>
 /// ROTs the specified vectorx.
 /// </summary>
 /// <param name="vectorx">The vectorx.</param>
 /// <param name="vectory">The vectory.</param>
 /// <param name="c">The c.</param>
 /// <param name="s">The s.</param>
 /// <param name="n">The n.</param>
 /// <param name="rowx">The rowx.</param>
 /// <param name="incx">The incx.</param>
 /// <param name="rowy">The rowy.</param>
 /// <param name="incy">The incy.</param>
 public abstract void ROT(ComplexF[] vectorx, ComplexF[] vectory, float[] c, float[] s, int n = 0, int rowx = 0, int incx = 1, int rowy = 0, int incy = 1);
예제 #19
0
 /// <summary>
 /// SCALs the specified alpha.
 /// </summary>
 /// <param name="alpha">The alpha.</param>
 /// <param name="vectorx">The vectorx.</param>
 /// <param name="n">The n.</param>
 /// <param name="rowx">The rowx.</param>
 /// <param name="incx">The incx.</param>
 public abstract void SCAL(float[] alpha, ComplexF[] vectorx, int n = 0, int rowx = 0, int incx = 1);
예제 #20
0
 /// <summary>
 /// SCALs the specified alpha.
 /// </summary>
 /// <param name="alpha">The alpha.</param>
 /// <param name="vectorx">The vectorx.</param>
 /// <param name="n">The n.</param>
 /// <param name="rowx">The rowx.</param>
 /// <param name="incx">The incx.</param>
 public void SCAL(float alpha, ComplexF[] vectorx, int n = 0, int rowx = 0, int incx = 1)
 {
     SCAL(new []{ alpha }, vectorx, n, rowx, incx);
 }
예제 #21
0
 /// <summary>
 /// IAMINs the specified vectorx.
 /// </summary>
 /// <param name="vectorx">The vectorx.</param>
 /// <param name="n">The n.</param>
 /// <param name="rowx">The rowx.</param>
 /// <param name="incx">The incx.</param>
 /// <returns></returns>
 public abstract int IAMIN(ComplexF[] vectorx, int n = 0, int rowx = 0, int incx = 1);
예제 #22
0
 /// <summary>
 /// Adds value y to value x.
 /// </summary>
 /// <param name="x">Value one.</param>
 /// <param name="y">Value to be added.</param>
 /// <returns>New value.</returns>
 public static ComplexF Add(ComplexF x, ComplexF y)
 {
     x.x = x.x + y.x;
     x.y = x.y + y.y;
     return(x);
 }
예제 #23
0
 /// <summary>
 /// AXPYs the specified alpha.
 /// </summary>
 /// <param name="alpha">The alpha.</param>
 /// <param name="vectorx">The vectorx.</param>
 /// <param name="vectory">The vectory.</param>
 /// <param name="n">The n.</param>
 /// <param name="rowx">The rowx.</param>
 /// <param name="incx">The incx.</param>
 /// <param name="rowy">The rowy.</param>
 /// <param name="incy">The incy.</param>
 public void AXPY(ComplexF alpha, ComplexD[] vectorx, ComplexD[] vectory, int n = 0, int rowx = 0, int incx = 1, int rowy = 0, int incy = 1)
 {
     AXPY(new [] { alpha }, vectorx, vectory, n, rowx, incx, rowy, incy);
 }
예제 #24
0
 public void SetUp()
 {
     _gpu = CudafyHost.CreateDevice(CudafyModes.Target);
      Console.WriteLine("CUDA driver version={0}", _gpu.GetDriverVersion());
     _fft = GPGPUFFT.Create(_gpu);
     _hostInput = new float[N * BATCH];
     _hostInputCplx = new ComplexF[N * BATCH];
     _hostOutput = new float[N * BATCH];
     _hostOutputCplx = new ComplexF[N * BATCH];
     _devInput = _gpu.Allocate(_hostInput);
     _devInputCplx = _gpu.Allocate(_hostInputCplx);
     _devInter = _gpu.Allocate<float>(N * 2 * BATCH);
     _devInterCplx = _gpu.Allocate<ComplexF>(N * BATCH);
     _devOutput = _gpu.Allocate(_hostOutput);
     _devOutputCplx = _gpu.Allocate(_hostOutputCplx);
     Console.WriteLine("CUFFT version={0}", _fft.GetVersion());
     for (int b = 0; b < BATCH; b++)
     {
         for (int i = 0; i < N; i++)
         {
             ComplexF cf = new ComplexF();
             cf.x = (float)((10.0F * Math.Sin(100 * 2 * Math.PI * i / N * Math.PI / 180)));
             cf.y = (float)((10.0F * Math.Sin(200 * 2 * Math.PI * i / N * Math.PI / 180)));
             _hostInput[i + b * N] = cf.x;
             _hostInputCplx[i + b * N] = cf;
         }
     }
 }
예제 #25
0
 /// <summary>
 /// AXPYs the specified alpha.
 /// </summary>
 /// <param name="alpha">The alpha.</param>
 /// <param name="vectorx">The vectorx.</param>
 /// <param name="vectory">The vectory.</param>
 /// <param name="n">The n.</param>
 /// <param name="rowx">The rowx.</param>
 /// <param name="incx">The incx.</param>
 /// <param name="rowy">The rowy.</param>
 /// <param name="incy">The incy.</param>
 protected abstract void AXPY(ComplexF[] alpha, ComplexD[] vectorx, ComplexD[] vectory, int n = 0, int rowx = 0, int incx = 1, int rowy = 0, int incy = 1);
예제 #26
0
 private static extern CUBLASStatusv2 cublasCdotc_v2(cublasHandle handle, int n, IntPtr x, int incx, IntPtr y, int incy, ref ComplexF result);
예제 #27
0
 /// <summary>
 /// COPYs the specified vectorx.
 /// </summary>
 /// <param name="vectorx">The vectorx.</param>
 /// <param name="vectory">The vectory.</param>
 /// <param name="n">The n.</param>
 /// <param name="rowx">The rowx.</param>
 /// <param name="incx">The incx.</param>
 /// <param name="rowy">The rowy.</param>
 /// <param name="incy">The incy.</param>
 public abstract void COPY(ComplexF[] vectorx, ComplexF[] vectory, int n = 0, int rowx = 0, int incx = 1, int rowy = 0, int incy = 1);
예제 #28
0
 private static extern CUBLASStatusv2 cublasCrotg_v2(cublasHandle handle, ref ComplexF a, ref ComplexF b, ref float c, ref ComplexF s);
예제 #29
0
 /// <summary>
 /// DOTCs the specified vectorx.
 /// </summary>
 /// <param name="vectorx">The vectorx.</param>
 /// <param name="vectory">The vectory.</param>
 /// <param name="n">The n.</param>
 /// <param name="rowx">The rowx.</param>
 /// <param name="incx">The incx.</param>
 /// <param name="rowy">The rowy.</param>
 /// <param name="incy">The incy.</param>
 /// <returns></returns>
 public abstract ComplexF DOTC(ComplexF[] vectorx, ComplexF[] vectory, int n = 0, int rowx = 0, int incx = 1, int rowy = 0, int incy = 1);
예제 #30
0
 public CUBLASStatusv2 cublasCdotc(cublasHandle handle, int n, IntPtr x, int incx, IntPtr y, int incy, ref ComplexF result)
 {
     return cublasCdotc_v2(handle, n, x, incx, y, incy, ref result);
 }
예제 #31
0
 /// <summary>
 /// NRs the m2.
 /// </summary>
 /// <param name="vectorx">The vectorx.</param>
 /// <param name="n">The n.</param>
 /// <param name="rowx">The rowx.</param>
 /// <param name="incx">The incx.</param>
 /// <returns></returns>
 public abstract float NRM2(ComplexF[] vectorx, int n = 0, int rowx = 0, int incx = 1);
예제 #32
0
 public CUBLASStatusv2 cublasCrotg(cublasHandle handle, ref ComplexF a, ref ComplexF b, ref float c, ref ComplexF s)
 {
     return cublasCrotg_v2(handle, ref a, ref b, ref c, ref s);
 }
예제 #33
0
 private static bool Verify(ComplexF x, ComplexF y, float delta)
 {
     if (Math.Abs(x.x - y.x) > delta || Math.Abs(x.y - y.y) > delta)
         return false;
     return true;
 }