import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
private void ddxt2d0_subth(final int isgn, final double[][] a, final boolean scale) {
    final int nthreads = ConcurrencyUtils.getNumberOfThreads() > rows ? rows : ConcurrencyUtils.getNumberOfThreads();

    Future<?>[] futures = new Future[nthreads];

    for (int i = 0; i < nthreads; i++) {
        final int n0 = i;
        futures[i] = ConcurrencyUtils.submit(new Runnable() {

            @Override
public void run() {
                if (isgn == -1) {
                    for (int r = n0; r < rows; r += nthreads) {
                        dctColumns.forward(a[r], scale);
                    }
                } else {
                    for (int r = n0; r < rows; r += nthreads) {
                        dctColumns.inverse(a[r], scale);
                    }
                }
            }
        });
    }
    ConcurrencyUtils.waitForCompletion(futures);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
/**
 * Creates new instance of FloatDCT_1D.
 * 
 * @param n
 *            size of data
 */
public FloatDCT_1D(int n) {
    if (n < 1) {
        throw new IllegalArgumentException("n must be greater than 0");
    }
    this.n = n;
    if (ConcurrencyUtils.isPowerOf2(n)) {
        this.isPowerOfTwo = true;
        this.ip = new int[(int) Math.ceil(2 + (1 << (int) (Math.log(n / 2 + 0.5) / Math.log(2)) / 2))];
        this.w = new float[n * 5 / 4];
        nw = ip[0];
        if (n > (nw << 2)) {
            nw = n >> 2;
            makewt(nw);
        }
        nc = ip[1];
        if (n > nc) {
            nc = n;
            makect(nc, w, nw);
        }
    } else {
        this.w = makect(n);
        fft = new FloatFFT_1D(2 * n);
    }
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
private void ddxt2d0_subth(final int isgn, final double[][] a, final boolean scale) {
    final int nthreads = ConcurrencyUtils.getNumberOfThreads() > rows ? rows : ConcurrencyUtils.getNumberOfThreads();

    Future<?>[] futures = new Future[nthreads];

    for (int i = 0; i < nthreads; i++) {
        final int n0 = i;
        futures[i] = ConcurrencyUtils.submit(new Runnable() {

            @Override
public void run() {
                if (isgn == -1) {
                    for (int r = n0; r < rows; r += nthreads) {
                        dstColumns.forward(a[r], scale);
                    }
                } else {
                    for (int r = n0; r < rows; r += nthreads) {
                        dstColumns.inverse(a[r], scale);
                    }
                }
            }
        });
    }
    ConcurrencyUtils.waitForCompletion(futures);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
private void ddxt2d0_subth(final int isgn, final float[] a, final boolean scale) {
    final int nthreads = ConcurrencyUtils.getNumberOfThreads() > rows ? rows : ConcurrencyUtils.getNumberOfThreads();

    Future<?>[] futures = new Future[nthreads];

    for (int i = 0; i < nthreads; i++) {
        final int n0 = i;
        futures[i] = ConcurrencyUtils.submit(new Runnable() {

            @Override
public void run() {
                if (isgn == -1) {
                    for (int r = n0; r < rows; r += nthreads) {
                        dstColumns.forward(a, r * columns, scale);
                    }
                } else {
                    for (int r = n0; r < rows; r += nthreads) {
                        dstColumns.inverse(a, r * columns, scale);
                    }
                }
            }
        });
    }
    ConcurrencyUtils.waitForCompletion(futures);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
private void ddxt2d0_subth(final int isgn, final float[][] a, final boolean scale) {
    final int nthreads = ConcurrencyUtils.getNumberOfThreads() > rows ? rows : ConcurrencyUtils.getNumberOfThreads();

    Future<?>[] futures = new Future[nthreads];

    for (int i = 0; i < nthreads; i++) {
        final int n0 = i;
        futures[i] = ConcurrencyUtils.submit(new Runnable() {

            @Override
public void run() {
                if (isgn == -1) {
                    for (int r = n0; r < rows; r += nthreads) {
                        dhtColumns.forward(a[r]);
                    }
                } else {
                    for (int r = n0; r < rows; r += nthreads) {
                        dhtColumns.inverse(a[r], scale);
                    }
                }
            }
        });
    }
    ConcurrencyUtils.waitForCompletion(futures);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
/**
 * Creates new instance of DoubleDCT_1D.
 * 
 * @param n
 *            size of data
 */
public DoubleDCT_1D(int n) {
    if (n < 1) {
        throw new IllegalArgumentException("n must be greater than 0");
    }
    this.n = n;
    if (ConcurrencyUtils.isPowerOf2(n)) {
        this.isPowerOfTwo = true;
        this.ip = new int[(int) Math.ceil(2 + (1 << (int) (Math.log(n / 2 + 0.5) / Math.log(2)) / 2))];
        this.w = new double[n * 5 / 4];
        nw = ip[0];
        if (n > (nw << 2)) {
            nw = n >> 2;
            makewt(nw);
        }
        nc = ip[1];
        if (n > nc) {
            nc = n;
            makect(nc, w, nw);
        }
    } else {
        this.w = makect(n);
        fft = new DoubleFFT_1D(2 * n);
    }
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
public void runAll() throws Exception {
	List<AbstractMatrix2DBenchmark> benchmarks = getDenseBenchmarks();

	UJMPSettings.getInstance().setNumberOfThreads(getConfig().getNumberOfThreads());
	ConcurrencyUtils.setNumberOfThreads(getConfig().getNumberOfThreads());
	System.setProperty("ATLAS_NUM_THREADS", "" + getConfig().getNumberOfThreads());

	if (getConfig().isShuffle()) {
		Collections.shuffle(benchmarks);
	}
	if (getConfig().isReverse()) {
		Collections.reverse(benchmarks);
	}

	long t0 = System.currentTimeMillis();

	for (int j = 0; j < benchmarks.size(); j++) {
		AbstractMatrix2DBenchmark benchmark = benchmarks.get(j);
		benchmark.run();
	}

	long t1 = System.currentTimeMillis();

	System.out.println();
	System.out.println("Finished.");
	System.out.println("Total Time: " + StringUtil.duration(t1 - t0));
	System.out.println();
	System.out.println();
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
public static void initCheck(Frame input, int width, int height, int depth) {
  ConcurrencyUtils.setNumberOfThreads(1);
  if (width < 1 || height < 1 || depth < 1)
    throw new H2OIllegalArgumentException("dimensions must be >= 1");
  if (width*height*depth != input.numCols())
    throw new H2OIllegalArgumentException("dimensions HxWxD must match the # columns of the frame");
  for (Vec v : input.vecs()) {
    if (v.naCnt() > 0)
      throw new H2OIllegalArgumentException("DCT can not be computed on rows with missing values");
    if (!v.isNumeric())
      throw new H2OIllegalArgumentException("DCT can only be computed on numeric columns");
  }
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
/**
 * Creates new instance of FloatDCT_2D.
 * 
 * @param rows
 *            number of rows
 * @param columns
 *            number of columns
 */
public FloatDCT_2D(int rows, int columns) {
    if (rows <= 1 || columns <= 1) {
        throw new IllegalArgumentException("rows and columns must be greater than 1");
    }
    this.rows = rows;
    this.columns = columns;
    if (rows * columns >= ConcurrencyUtils.getThreadsBeginN_2D()) {
        this.useThreads = true;
    }
    if (ConcurrencyUtils.isPowerOf2(rows) && ConcurrencyUtils.isPowerOf2(columns)) {
        isPowerOfTwo = true;
        oldNthreads = ConcurrencyUtils.getNumberOfThreads();
        nt = 4 * oldNthreads * rows;
        if (columns == 2 * oldNthreads) {
            nt >>= 1;
        } else if (columns < 2 * oldNthreads) {
            nt >>= 2;
        }
        t = new float[nt];
    }
    dctColumns = new FloatDCT_1D(columns);
    if (columns == rows) {
        dctRows = dctColumns;
    } else {
        dctRows = new FloatDCT_1D(rows);
    }
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
/**
 * Computes 2D forward DFT of real data leaving the result in <code>a</code>
 * . This method computes full real forward transform, i.e. you will get the
 * same result as from <code>complexForward</code> called with all imaginary
 * part equal 0. Because the result is stored in <code>a</code>, the input
 * array must be of size rows*2*columns, with only the first rows*columns
 * elements filled with real data. To get back the original data, use
 * <code>complexInverse</code> on the output of this method.
 * 
 * @param a
 *            data to transform
 */
public void realForwardFull(float[] a) {
    if (isPowerOfTwo) {
        int nthreads;

        nthreads = ConcurrencyUtils.getNumberOfThreads();
        if (nthreads != oldNthreads) {
            nt = 8 * nthreads * rows;
            if (columns == 4 * nthreads) {
                nt >>= 1;
            } else if (columns < 4 * nthreads) {
                nt >>= 2;
            }
            t = new float[nt];
            oldNthreads = nthreads;
        }
        if ((nthreads > 1) && useThreads) {
            xdft2d0_subth1(1, 1, a, true);
            cdft2d_subth(-1, a, true);
            rdft2d_sub(1, a);
        } else {
            for (int r = 0; r < rows; r++) {
                fftColumns.realForward(a, r * columns);
            }
            cdft2d_sub(-1, a, true);
            rdft2d_sub(1, a);
        }
        fillSymmetric(a);
    } else {
        mixedRadixRealForwardFull(a);
    }
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
public FloatingPointEqualityChecker createEqualityChecker(final float rel,
		final float abs)
{
	final String msg = String.format(DEFAULT_MESSAGE,
			ConcurrencyUtils.getNumberOfThreads(), numRows, numCols);
	return new FloatingPointEqualityChecker(msg, 0d, 0d, rel, abs);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
/**
 * Computes 2D inverse DFT of real data leaving the result in <code>a</code>
 * . This method computes full real inverse transform, i.e. you will get the
 * same result as from <code>complexInverse</code> called with all imaginary
 * part equal 0. Because the result is stored in <code>a</code>, the input
 * array must be of size rows*2*columns, with only the first rows*columns
 * elements filled with real data.
 * 
 * @param a
 *            data to transform
 * 
 * @param scale
 *            if true then scaling is performed
 */
public void realInverseFull(float[] a, boolean scale) {
    if (isPowerOfTwo) {
        int nthreads;

        nthreads = ConcurrencyUtils.getNumberOfThreads();
        if (nthreads != oldNthreads) {
            nt = 8 * nthreads * rows;
            if (columns == 4 * nthreads) {
                nt >>= 1;
            } else if (columns < 4 * nthreads) {
                nt >>= 2;
            }
            t = new float[nt];
            oldNthreads = nthreads;
        }
        if ((nthreads > 1) && useThreads) {
            xdft2d0_subth2(1, -1, a, scale);
            cdft2d_subth(1, a, scale);
            rdft2d_sub(1, a);
        } else {
            for (int r = 0; r < rows; r++) {
                fftColumns.realInverse2(a, r * columns, scale);
            }
            cdft2d_sub(1, a, scale);
            rdft2d_sub(1, a);
        }
        fillSymmetric(a);
    } else {
        mixedRadixRealInverseFull(a, scale);
    }
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
private void xdft2d0_subth1(final int icr, final int isgn, final float[] a, final boolean scale) {
    final int nthreads = ConcurrencyUtils.getNumberOfThreads() > rows ? rows : ConcurrencyUtils.getNumberOfThreads();

    Future<?>[] futures = new Future[nthreads];
    for (int i = 0; i < nthreads; i++) {
        final int n0 = i;
        futures[i] = ConcurrencyUtils.submit(new Runnable() {
            @Override
public void run() {
                if (icr == 0) {
                    if (isgn == -1) {
                        for (int r = n0; r < rows; r += nthreads) {
                            fftColumns.complexForward(a, r * columns);
                        }
                    } else {
                        for (int r = n0; r < rows; r += nthreads) {
                            fftColumns.complexInverse(a, r * columns, scale);
                        }
                    }
                } else {
                    if (isgn == 1) {
                        for (int r = n0; r < rows; r += nthreads) {
                            fftColumns.realForward(a, r * columns);
                        }
                    } else {
                        for (int r = n0; r < rows; r += nthreads) {
                            fftColumns.realInverse(a, r * columns, scale);
                        }
                    }
                }
            }
        });
    }
    ConcurrencyUtils.waitForCompletion(futures);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
public FloatingPointEqualityChecker createEqualityChecker(final double rel,
		final double abs)
{
	final String msg = String.format(DEFAULT_MESSAGE,
			ConcurrencyUtils.getNumberOfThreads(), numRows, numCols);
	return new FloatingPointEqualityChecker(msg, rel, abs, 0f, 0f);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
private void xdft2d0_subth2(final int icr, final int isgn, final float[][] a, final boolean scale) {
    final int nthreads = ConcurrencyUtils.getNumberOfThreads() > rows ? rows : ConcurrencyUtils.getNumberOfThreads();

    Future<?>[] futures = new Future[nthreads];
    for (int i = 0; i < nthreads; i++) {
        final int n0 = i;
        futures[i] = ConcurrencyUtils.submit(new Runnable() {
            @Override
public void run() {
                if (icr == 0) {
                    if (isgn == -1) {
                        for (int r = n0; r < rows; r += nthreads) {
                            fftColumns.complexForward(a[r]);
                        }
                    } else {
                        for (int r = n0; r < rows; r += nthreads) {
                            fftColumns.complexInverse(a[r], scale);
                        }
                    }
                } else {
                    if (isgn == 1) {
                        for (int r = n0; r < rows; r += nthreads) {
                            fftColumns.realForward(a[r]);
                        }
                    } else {
                        for (int r = n0; r < rows; r += nthreads) {
                            fftColumns.realInverse2(a[r], 0, scale);
                        }
                    }
                }
            }
        });
    }
    ConcurrencyUtils.waitForCompletion(futures);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
/**
 * Computes 3D forward DFT of real data leaving the result in <code>a</code>
 * . This method computes full real forward transform, i.e. you will get the
 * same result as from <code>complexForward</code> called with all imaginary
 * part equal 0. Because the result is stored in <code>a</code>, the input
 * array must be of size slices*rows*2*columns, with only the first slices*rows*columns elements
 * filled with real data. To get back the original data, use
 * <code>complexInverse</code> on the output of this method.
 * 
 * @param a
 *            data to transform
 */
public void realForwardFull(double[] a) {
    if (isPowerOfTwo) {
        int nthreads = ConcurrencyUtils.getNumberOfThreads();
        if (nthreads != oldNthreads) {
            nt = slices;
            if (nt < rows) {
                nt = rows;
            }
            nt *= 8;
            if (nthreads > 1) {
                nt *= nthreads;
            }
            if (columns == 4) {
                nt >>= 1;
            } else if (columns < 4) {
                nt >>= 2;
            }
            t = new double[nt];
            oldNthreads = nthreads;
        }
        if ((nthreads > 1) && useThreads) {
            xdft3da_subth2(1, -1, a, true);
            cdft3db_subth(-1, a, true);
            rdft3d_sub(1, a);
        } else {
            xdft3da_sub2(1, -1, a, true);
            cdft3db_sub(-1, a, true);
            rdft3d_sub(1, a);
        }
        fillSymmetric(a);
    } else {
        mixedRadixRealForwardFull(a);
    }
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
public static void benchmarkForward_3D_input_1D() {
	final double[] times = new double[nsize];
	float[] x;
	for (int i = 0; i < nsize; i++) {
		System.out.println("Forward DHT 3D (input 1D) of size " + sizes3D[i] + " x " + sizes3D[i] + " x "
				+ sizes3D[i]);
		FloatDHT_3D dht3 = new FloatDHT_3D(sizes3D[i], sizes3D[i], sizes3D[i]);
		x = new float[sizes3D[i] * sizes3D[i] * sizes3D[i]];
		if (doWarmup) { // call the transform twice to warm up
			IOUtils.fillMatrix_3D(sizes3D[i], sizes3D[i], sizes3D[i], x);
			dht3.forward(x);
			IOUtils.fillMatrix_3D(sizes3D[i], sizes3D[i], sizes3D[i], x);
			dht3.forward(x);
		}
		float av_time = 0;
		long elapsedTime = 0;
		for (int j = 0; j < niter; j++) {
			IOUtils.fillMatrix_3D(sizes3D[i], sizes3D[i], sizes3D[i], x);
			elapsedTime = System.nanoTime();
			dht3.forward(x);
			elapsedTime = System.nanoTime() - elapsedTime;
			av_time = av_time + elapsedTime;
		}
		times[i] = av_time / 1000000.0 / niter;
		System.out.println("Average execution time: " + String.format("%.2f", av_time / 1000000.0 / niter) + " msec");
		x = null;
		dht3 = null;
		System.gc();
		ConcurrencyUtils.sleep(5000);
	}
	IOUtils.writeFFTBenchmarkResultsToFile("benchmarkFloatForwardDHT_3D_input_1D.txt", nthread, niter, doWarmup,
			doScaling, sizes3D, times);

}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
/**
 * Computes 3D inverse DFT of real data leaving the result in <code>a</code>
 * . This method computes full real inverse transform, i.e. you will get the
 * same result as from <code>complexInverse</code> called with all imaginary
 * part equal 0. Because the result is stored in <code>a</code>, the input
 * array must be of size slices*rows*2*columns, with only the first slices*rows*columns elements
 * filled with real data.
 * 
 * @param a
 *            data to transform
 * @param scale
 *            if true then scaling is performed
 */
public void realInverseFull(double[] a, boolean scale) {
    if (isPowerOfTwo) {
        int nthreads = ConcurrencyUtils.getNumberOfThreads();
        if (nthreads != oldNthreads) {
            nt = slices;
            if (nt < rows) {
                nt = rows;
            }
            nt *= 8;
            if (nthreads > 1) {
                nt *= nthreads;
            }
            if (columns == 4) {
                nt >>= 1;
            } else if (columns < 4) {
                nt >>= 2;
            }
            t = new double[nt];
            oldNthreads = nthreads;
        }
        if ((nthreads > 1) && useThreads) {
            xdft3da_subth2(1, 1, a, scale);
            cdft3db_subth(1, a, scale);
            rdft3d_sub(1, a);
        } else {
            xdft3da_sub2(1, 1, a, scale);
            cdft3db_sub(1, a, scale);
            rdft3d_sub(1, a);
        }
        fillSymmetric(a);
    } else {
        mixedRadixRealInverseFull(a, scale);
    }
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
public static void parseArguments(String[] args) {
	if (args.length > 0) {
		nthread = Integer.parseInt(args[0]);
		threadsBegin2D = Integer.parseInt(args[1]);
		threadsBegin3D = Integer.parseInt(args[2]);
		niter = Integer.parseInt(args[3]);
		doWarmup = Boolean.parseBoolean(args[4]);
		doScaling = Boolean.parseBoolean(args[5]);
		nsize = Integer.parseInt(args[6]);
		sizes1D = new int[nsize];
		sizes2D = new int[nsize];
		sizes3D = new int[nsize];
		for (int i = 0; i < nsize; i++) {
			sizes1D[i] = Integer.parseInt(args[7 + i]);
		}
		for (int i = 0; i < nsize; i++) {
			sizes2D[i] = Integer.parseInt(args[7 + nsize + i]);
		}
		for (int i = 0; i < nsize; i++) {
			sizes3D[i] = Integer.parseInt(args[7 + nsize + nsize + i]);
		}
	} else {
		System.out.println("Default settings are used.");
	}
	ConcurrencyUtils.setNumberOfThreads(nthread);
	ConcurrencyUtils.setThreadsBeginN_2D(threadsBegin2D);
	ConcurrencyUtils.setThreadsBeginN_3D(threadsBegin3D);
	System.out.println("nthred = " + nthread);
	System.out.println("threadsBegin2D = " + threadsBegin2D);
	System.out.println("threadsBegin3D = " + threadsBegin3D);
	System.out.println("niter = " + niter);
	System.out.println("doWarmup = " + doWarmup);
	System.out.println("doScaling = " + doScaling);
	System.out.println("nsize = " + nsize);
	System.out.println("sizes1D[] = " + Arrays.toString(sizes1D));
	System.out.println("sizes2D[] = " + Arrays.toString(sizes2D));
	System.out.println("sizes3D[] = " + Arrays.toString(sizes3D));
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入依赖的package包/类
public static void benchmarkComplexForward_1D() {
	float[] x;
	final double[] times = new double[nsize];
	for (int i = 0; i < nsize; i++) {
		System.out.println("Complex forward FFT 1D of size " + sizes1D[i]);
		FloatFFT_1D fft = new FloatFFT_1D(sizes1D[i]);
		x = new float[2 * sizes1D[i]];
		if (doWarmup) { // call the transform twice to warm up
			IOUtils.fillMatrix_1D(2 * sizes1D[i], x);
			fft.complexForward(x);
			IOUtils.fillMatrix_1D(2 * sizes1D[i], x);
			fft.complexForward(x);
		}
		float av_time = 0;
		long elapsedTime = 0;
		for (int j = 0; j < niter; j++) {
			IOUtils.fillMatrix_1D(2 * sizes1D[i], x);
			elapsedTime = System.nanoTime();
			fft.complexForward(x);
			elapsedTime = System.nanoTime() - elapsedTime;
			av_time = av_time + elapsedTime;
		}
		times[i] = av_time / 1000000.0 / niter;
		System.out.println("\tAverage execution time: " + String.format("%.2f", av_time / 1000000.0 / niter)
				+ " msec");
		x = null;
		fft = null;
		System.gc();
		ConcurrencyUtils.sleep(5000);
	}
	IOUtils.writeFFTBenchmarkResultsToFile("benchmarkFloatComplexForwardFFT_1D.txt", nthread, niter, doWarmup,
			doScaling, sizes1D, times);

}