void generate_testvectors(size_t key_len, size_t npub_len) {
size_t ad_len, msg_len, i, c = 1;
uint8_t ad[3 * PI_PT_BLOCK_LENGTH_BYTES / 2];
uint8_t msg[3 * PI_PT_BLOCK_LENGTH_BYTES / 2];
uint8_t key[key_len];
uint8_t npub[npub_len];
uint8_t nsec[PI_PT_BLOCK_LENGTH_BYTES];
{
char seed[64];
snprintf(seed, sizeof(seed), "%s%03zuv2 (%zu byte nonce)", pi_cipher_name, key_len * 8, npub_len);
init_prng(seed, strlen(seed));
}
for (msg_len = 0; msg_len <= sizeof(msg); ++msg_len) {
for (ad_len = 0; ad_len <= sizeof(ad); ++ad_len) {
printf("[msg_len = %zu]\n", msg_len);
printf("[ad_len = %zu]\n\n", ad_len);
for (i = 0; i < 9; ++i) {
printf("[vector #%zu (%zu)]\n", c, i + 1);
++c;
fill_random(key, sizeof(key));
fill_random(npub, sizeof(npub));
if (i < 8) {
fill_random(nsec, sizeof(nsec));
}
fill_random(ad, ad_len);
fill_random(msg, msg_len);
generate_single_testvector(msg, msg_len, ad, ad_len, (i == 8) ? NULL : nsec, npub, npub_len, key, key_len);
}
}
}
}
/**
* In the main routine we set up a matrix V and compute approximate factors W and H such that \f$V \approx W H \f$, where all three matrices carry nonnegative entries only.
* Since W and H are usually chosen to represent a rank-k-approximation of V, we use a similar low-rank approximation here.
**/
int main()
{
std::cout << std::endl;
std::cout << "------- Tutorial NMF --------" << std::endl;
std::cout << std::endl;
/**
* Approximate the 7-by-6-matrix V by a 7-by-3-matrix W and a 3-by-6-matrix H
**/
unsigned int m = 7; //size1 of W and size1 of V
unsigned int n = 6; //size2 of V and size2 of H
unsigned int k = 3; //size2 of W and size1 of H
viennacl::matrix<ScalarType, viennacl::column_major> V(m, n);
viennacl::matrix<ScalarType, viennacl::column_major> W(m, k);
viennacl::matrix<ScalarType, viennacl::column_major> H(k, n);
/**
* Fill the matrices randomly. Initial guesses for W and H consisting of only zeros won't work.
**/
fill_random(V);
fill_random(W);
fill_random(H);
std::cout << "Input matrices:" << std::endl;
std::cout << "V" << V << std::endl;
std::cout << "W" << W << std::endl;
std::cout << "H" << H << "\n" << std::endl;
/**
* Create configuration object to hold (and adjust) the respective parameters.
**/
viennacl::linalg::nmf_config conf;
conf.print_relative_error(false);
conf.max_iterations(50); // 50 iterations are enough here
/**
* Call the NMF routine and print the results
**/
std::cout << "Computing NMF" << std::endl;
viennacl::linalg::nmf(V, W, H, conf);
std::cout << "RESULT:" << std::endl;
std::cout << "V" << V << std::endl;
std::cout << "W" << W << std::endl;
std::cout << "H" << H << "\n" << std::endl;
/**
* Print the product W*H approximating V for comparison and exit:
**/
std::cout << "W*H:" << std::endl;
viennacl::matrix<ScalarType> resultCorrect = viennacl::linalg::prod(W, H);
std::cout << resultCorrect << std::endl;
std::cout << std::endl;
std::cout << "------- Tutorial completed --------" << std::endl;
std::cout << std::endl;
}
void ProjectionsCase_tests::setUp()
{
h = new TH2DA("h", "h", 10, -5, 5, 10, -5, 5);
fill_random(h);
hd = new TH2D("hd", "hd", 10, -5, 5, 10, -5, 5);
hd->Sumw2();
fill_random(hd);
}
static void test_motion(const char *name,
me_cmp_func test_func, me_cmp_func ref_func)
{
int x, y, d1, d2, it;
uint8_t *ptr;
int64_t ti;
printf("testing '%s'\n", name);
/* test correctness */
for(it=0; it<20; it++)
{
fill_random(img1, WIDTH * HEIGHT);
fill_random(img2, WIDTH * HEIGHT);
for(y=0; y<HEIGHT-17; y++)
{
for(x=0; x<WIDTH-17; x++)
{
ptr = img2 + y * WIDTH + x;
d1 = test_func(NULL, img1, ptr, WIDTH, 1);
d2 = ref_func(NULL, img1, ptr, WIDTH, 1);
if (d1 != d2)
{
printf("error: mmx=%d c=%d\n", d1, d2);
}
}
}
}
emms_c();
/* speed test */
ti = gettime();
d1 = 0;
for(it=0; it<NB_ITS; it++)
{
for(y=0; y<HEIGHT-17; y++)
{
for(x=0; x<WIDTH-17; x++)
{
ptr = img2 + y * WIDTH + x;
d1 += test_func(NULL, img1, ptr, WIDTH, 1);
}
}
}
emms_c();
dummy = d1; /* avoid optimization */
ti = gettime() - ti;
printf(" %0.0f kop/s\n",
(double)NB_ITS * (WIDTH - 16) * (HEIGHT - 16) /
(double)(ti / 1000.0));
}
static void fill(int64_t *dst, const int size, int type)
{
switch (type) {
case FILL_SORTED:
fill_sorted(dst, size);
break;
case FILL_SORTED_10:
fill_sorted_blocks(dst, size, 10);
break;
case FILL_SORTED_100:
fill_sorted_blocks(dst, size, 100);
break;
case FILL_SORTED_10000:
fill_sorted_blocks(dst, size, 10000);
break;
case FILL_SWAPPED_N2:
fill_swapped(dst, size, size/2);
break;
case FILL_SWAPPED_N8:
fill_swapped(dst, size, size/8);
case FILL_RANDOM:
default:
fill_random(dst, size);
break;
}
}
void fill_random( const View<Sacado::UQ::PCE<S>**,L,D,M>& a,
RandomPool g,
const Sacado::UQ::PCE<S>& begin,
const Sacado::UQ::PCE<S>& end ) {
typedef View<Sacado::UQ::PCE<S>**,L,D,M> Vector;
typename Vector::flat_array_type a_flat = a;
fill_random( a_flat, g, begin.fastAccessCoeff(0), end.fastAccessCoeff(0) );
}
void fill_random( const View<Sacado::UQ::PCE<S>**,P...>& a,
RandomPool g,
const Sacado::UQ::PCE<S>& begin,
const Sacado::UQ::PCE<S>& end ) {
typedef View<Sacado::UQ::PCE<S>**,P...> Vector;
typename Kokkos::FlatArrayType<Vector>::type a_flat = a;
fill_random( a_flat, g, begin.fastAccessCoeff(0), end.fastAccessCoeff(0) );
}
static void process_region_list(romload_private *romdata)
{
astring regiontag;
/* loop until we hit the end */
device_iterator deviter(romdata->machine().root_device());
for (device_t *device = deviter.first(); device != NULL; device = deviter.next())
for (const rom_entry *region = rom_first_region(*device); region != NULL; region = rom_next_region(region))
{
UINT32 regionlength = ROMREGION_GETLENGTH(region);
rom_region_name(regiontag, *device, region);
LOG(("Processing region \"%s\" (length=%X)\n", regiontag.cstr(), regionlength));
/* the first entry must be a region */
assert(ROMENTRY_ISREGION(region));
if (ROMREGION_ISROMDATA(region))
{
/* if this is a device region, override with the device width and endianness */
UINT8 width = ROMREGION_GETWIDTH(region) / 8;
endianness_t endianness = ROMREGION_ISBIGENDIAN(region) ? ENDIANNESS_BIG : ENDIANNESS_LITTLE;
if (romdata->machine().device(regiontag) != NULL)
normalize_flags_for_device(romdata->machine(), regiontag, width, endianness);
/* remember the base and length */
romdata->region = romdata->machine().memory().region_alloc(regiontag, regionlength, width, endianness);
LOG(("Allocated %X bytes @ %p\n", romdata->region->bytes(), romdata->region->base()));
/* clear the region if it's requested */
if (ROMREGION_ISERASE(region))
memset(romdata->region->base(), ROMREGION_GETERASEVAL(region), romdata->region->bytes());
/* or if it's sufficiently small (<= 4MB) */
else if (romdata->region->bytes() <= 0x400000)
memset(romdata->region->base(), 0, romdata->region->bytes());
#ifdef MAME_DEBUG
/* if we're debugging, fill region with random data to catch errors */
else
fill_random(romdata->machine(), romdata->region->base(), romdata->region->bytes());
#endif
/* now process the entries in the region */
process_rom_entries(romdata, device->shortname(), region, region + 1, device, FALSE);
}
else if (ROMREGION_ISDISKDATA(region))
process_disk_entries(romdata, regiontag, region, region + 1, NULL);
}
/* now go back and post-process all the regions */
for (device_t *device = deviter.first(); device != NULL; device = deviter.next())
for (const rom_entry *region = rom_first_region(*device); region != NULL; region = rom_next_region(region))
{
rom_region_name(regiontag, *device, region);
region_post_process(romdata, regiontag, ROMREGION_ISINVERTED(region));
}
}
void test_nmf(std::size_t m, std::size_t k, std::size_t n)
{
std::vector<ScalarType> stl_w(m * k);
std::vector<ScalarType> stl_h(k * n);
viennacl::matrix<ScalarType> v_ref(m, n);
viennacl::matrix<ScalarType> w_ref(m, k);
viennacl::matrix<ScalarType> h_ref(k, n);
fill_random(stl_w);
fill_random(stl_h);
viennacl::fast_copy(&stl_w[0], &stl_w[0] + stl_w.size(), w_ref);
viennacl::fast_copy(&stl_h[0], &stl_h[0] + stl_h.size(), h_ref);
v_ref = viennacl::linalg::prod(w_ref, h_ref); //reference
// Fill again with random numbers:
fill_random(stl_w);
fill_random(stl_h);
viennacl::matrix<ScalarType> w_nmf(m, k);
viennacl::matrix<ScalarType> h_nmf(k, n);
viennacl::fast_copy(&stl_w[0], &stl_w[0] + stl_w.size(), w_nmf);
viennacl::fast_copy(&stl_h[0], &stl_h[0] + stl_h.size(), h_nmf);
viennacl::linalg::nmf_config conf;
viennacl::linalg::nmf(v_ref, w_nmf, h_nmf, conf);
viennacl::matrix<ScalarType> v_nmf = viennacl::linalg::prod(w_nmf, h_nmf);
float diff = matrix_compare(v_ref, v_nmf);
bool diff_ok = fabs(diff) < EPS;
long iterations = static_cast<long>(conf.iters());
printf("%6s [%lux%lux%lu] diff = %.6f (%ld iterations)\n", diff_ok ? "[[OK]]":"[FAIL]", m, k, n, diff, iterations);
if (!diff_ok)
exit(EXIT_FAILURE);
}
static void fill_sorted_blocks(int64_t *dst, const int size, const int block_size) {
int i, filled, this_block_size;
filled = 0;
for (i = 0; i < size; i += block_size) {
this_block_size = (filled + block_size) < size ? block_size : (size - filled);
fill_random(dst + filled, this_block_size);
qsort(dst + filled, this_block_size, sizeof(int64_t), simple_cmp);
filled += this_block_size;
}
}
int rom_load_manager::rom_fread(UINT8 *buffer, int length, const rom_entry *parent_region)
{
/* files just pass through */
if (m_file != nullptr)
return m_file->read(buffer, length);
/* otherwise, fill with randomness unless it was already specifically erased */
else if (!ROMREGION_ISERASE(parent_region))
fill_random(buffer, length);
return length;
}
static int rom_fread(romload_private *romdata, UINT8 *buffer, int length, const rom_entry *parent_region)
{
/* files just pass through */
if (romdata->file != NULL)
return romdata->file->read(buffer, length);
/* otherwise, fill with randomness unless it was already specifically erased */
else if (!ROMREGION_ISERASE(parent_region))
fill_random(romdata->machine(), buffer, length);
return length;
}
static int rom_fread(struct rom_load_data *romdata, UINT8 *buffer, int length)
{
/* files just pass through */
if (romdata->file)
return mame_fread(romdata->file, buffer, length);
/* otherwise, fill with randomness */
else
fill_random(buffer, length);
return length;
}
static double verify_linear(fftd_func *dft,
int N,
COMPLEX *inA,
COMPLEX *inB,
COMPLEX *inC,
COMPLEX *outA,
COMPLEX *outB,
COMPLEX *outC,
COMPLEX *tmp,
int rounds)
{
int i; double maxerr = 0.0; double e;
/* test 1: check linearity */
for (i = 0; i < rounds; ++i) {
COMPLEX alpha, beta;
RE(alpha) = double_rand();
IM(alpha) = double_rand();
RE(beta) = double_rand();
IM(beta) = double_rand();
fill_random(inA, N);
fill_random(inB, N);
dft((double *)outA, (double *)inA);
dft((double *)outB, (double *)inB);
ascale(outA, alpha, N);
ascale(outB, beta, N);
aadd(tmp, outA, outB, N);
ascale(inA, alpha, N);
ascale(inB, beta, N);
aadd(inC, inA, inB, N);
dft((double *)outC, (double *)inC);
e = acmp(outC, tmp, N);
if(e > maxerr) maxerr = e;
}
return maxerr;
}
void testrandomlists(int n, int size)
{
for(int i=0; i<n; i++)
{
int list[size];
int check[size];
fill_random(list, size);
list_copy(list, check, size);
insertionSort(list, size);
insertionSortSafe(check, size);
if(!list_equal(list, check, size))
printf("FAIL!\n");
}
}
int main()
{
int ii = 4;
int jj = 3;
int kk = 2;
int ll = 5;
int mm = 6;
int nn = 7;
quad_type matA(ll,kk,jj,ii);
quad_type matB(nn,mm,jj,ii);
quad_type matC(ll,kk,nn,mm);
fill_random(matB);
fill_random(matC);
//fill_from_file(matB, "B.mat");
//fill_from_file(matC, "C.mat");
libmda::cindex<'i'> i;
libmda::cindex<'j'> j;
libmda::cindex<'k'> k;
libmda::cindex<'l'> l;
libmda::cindex<'m'> m;
libmda::cindex<'n'> n;
auto start = std::chrono::steady_clock::now();
matA(l,k,j,i) = matB(n,m,j,i) * matC(l,k,n,m);
auto stop = std::chrono::steady_clock::now();
auto diff = stop - start;
std::cout << std::chrono::duration<double, std::milli>(diff).count() << "ms" << std::endl;
print(matA, "A.data");
print(matB, "B.data");
print(matC, "C.data");
return 0;
}
static double verify_impulse(fftd_func *dft,
int n, int veclen,
COMPLEX *inA,
COMPLEX *inB,
COMPLEX *inC,
COMPLEX *outA,
COMPLEX *outB,
COMPLEX *outC,
COMPLEX *tmp,
int rounds)
{
int N = n * veclen;
COMPLEX impulse;
int i;
double e, maxerr = 0.0;
/* test 2: check that the unit impulse is transformed properly */
RE(impulse) = 1.0;
IM(impulse) = 0.0;
for (i = 0; i < N; ++i) {
/* impulse */
RE(inA[i]) = 0.0;
IM(inA[i]) = 0.0;
/* transform of the impulse */
outA[i] = impulse;
}
for (i = 0; i < veclen; ++i)
inA[i * n] = impulse;
/* a simple test first, to help with debugging: */
dft((double *)outB, (double *)inA);
e = acmp(outB, outA, N);
if(e > maxerr) maxerr = e;
for (i = 0; i < rounds; ++i) {
fill_random(inB, N);
asub(inC, inA, inB, N);
dft((double *)outB, (double *)inB);
dft((double *)outC, (double *)inC);
aadd(tmp, outB, outC, N);
e = acmp(tmp, outA, N);
if(e > maxerr) maxerr = e;
}
return maxerr;
}
int main(void)
{
int i = 0;
int64_t sizes[TESTS];
srand48(SEED);
fill_random(sizes, TESTS);
for (i = 0; i < TESTS; i++) {
RAND_RANGE(sizes[i], 0, MAXSIZE);
}
for (i = 0; i < FILL_LAST_ELEMENT; i++) {
run_tests(sizes, TESTS, i);
}
return 0;
}
int main(int argc,char* argv[]){
if(argc<3){
printf("%s <troll port> <troll host>\n",argv[0]);
return -1;
}
/*
if(test1()){
printf("test 1 passed\n");
}else{
printf("test 1 failed\n");
}
if(test2()){
printf("test 2 passed\n");
}else{
printf("test 2 failed\n");
}
*/
int bytes_data = 4;
char TCP_header[4*6+bytes_data];
char TCP_header_og[4*6+bytes_data];
int i = 0;
int numtests = 10;
for(;i<numtests;i++){
fill_random(TCP_header,4*6+bytes_data);
insertChecksum(TCP_header,4*6+bytes_data);
bcopy(TCP_header,TCP_header_og,4*6+bytes_data);
printf("\nsending to troll:");
printTCP(TCP_header,4*6+bytes_data);
trollify(TCP_header,4*6+bytes_data,atoi(argv[1]),argv[2]);
printf("\ngot back");
printTCP(TCP_header,4*6+bytes_data);
printf("isValidCRC says: ");
if(isValidCRC(TCP_header,4*6+bytes_data)){
printf("true\n");
}else{
printf("false\n");
}
}
return 0;
}
int main(int argc, char* argv[]) {
int data[SIZE];
fill_random(data, SIZE);
int sorted[SIZE];
for (int i = 0; i < SIZE; i++) {
sorted[i] = data[i];
}
bubblesort(sorted, SIZE);
printf("Der Inhalt des Arrays ist: \n"); print_array(data, SIZE);
printf("Der Inhalt des sortierten Arrays ist: \n"); print_array(sorted, SIZE);
printf("Der Durchschnitt der im Array enthaltenen Zahlen ist %.2f\n", average(data, SIZE));
printf("Der Median der im Array enthaltenen Zahlen ist %.2f\n", median(data, SIZE));
printf("Die kleinste Zahl in dem Array ist %d\n", minimum(data, SIZE));
printf("Die groesste Zahl in dem Array ist %d\n", maximum(data, SIZE));
printf("Die Summe der im Array enthaltenen Zahlen ist %d\n", sum(data, SIZE));
printf("Die Varianz der im Array enthaltenen Zahlen ist %.2f\n", variance(data, SIZE));
printf("Die Standardabweichung der im Array enthaltenen Zahlen ist %.2f\n\n", stddev(data, SIZE));
return 0;
}
static double verify_shift(fftd_func *dft,
int N,
COMPLEX *inA,
COMPLEX *inB,
COMPLEX *outA,
COMPLEX *outB,
COMPLEX *tmp,
int rounds)
{
const double twopin = 2 * M_PI / (double) N;
int i, j;
double e, maxerr = 0.0;
/* test 3: check the time-shift property */
/* the paper performs more tests, but this code should be fine too */
for (i = 0; i < rounds; ++i) {
fill_random(inA, N);
arol(inB, inA, N, 1);
dft((double *)outA, (double *)inA);
dft((double *)outB, (double *)inB);
for (j = 0; j < N; ++j) {
double s = SIGN * sin(j * twopin);
double c = cos(j * twopin);
int index = j;
RE(tmp[index]) = RE(outB[index]) * c - IM(outB[index]) * s;
IM(tmp[index]) = RE(outB[index]) * s + IM(outB[index]) * c;
}
e = acmp(tmp, outA, N);
if(e > maxerr) maxerr = e;
}
return maxerr;
}
void rom_init(running_machine *machine, const rom_entry *romp)
{
const rom_entry *regionlist[REGION_MAX];
const rom_entry *region;
static rom_load_data romdata;
int regnum;
/* if no roms, bail */
if (romp == NULL)
return;
/* make sure we get called back on the way out */
add_exit_callback(machine, rom_exit);
/* reset the region list */
memset((void *)regionlist, 0, sizeof(regionlist));
/* reset the romdata struct */
memset(&romdata, 0, sizeof(romdata));
romdata.romstotal = count_roms(romp);
/* reset the disk list */
memset(disk_handle, 0, sizeof(disk_handle));
/* determine the correct biosset to load based on options.bios string */
system_bios = determine_bios_rom(Machine->gamedrv->bios);
/* loop until we hit the end */
for (region = romp, regnum = 0; region; region = rom_next_region(region), regnum++)
{
int regiontype = ROMREGION_GETTYPE(region);
debugload("Processing region %02X (length=%X)\n", regiontype, ROMREGION_GETLENGTH(region));
/* the first entry must be a region */
assert(ROMENTRY_ISREGION(region));
/* remember the base and length */
romdata.regionbase = new_memory_region(machine, regiontype, ROMREGION_GETLENGTH(region), ROMREGION_GETFLAGS(region));
romdata.regionlength = ROMREGION_GETLENGTH(region);
debugload("Allocated %X bytes @ %08X\n", romdata.regionlength, (int)romdata.regionbase);
/* clear the region if it's requested */
if (ROMREGION_ISERASE(region))
memset(romdata.regionbase, ROMREGION_GETERASEVAL(region), romdata.regionlength);
/* or if it's sufficiently small (<= 4MB) */
else if (romdata.regionlength <= 0x400000)
memset(romdata.regionbase, 0, romdata.regionlength);
#ifdef MAME_DEBUG
/* if we're debugging, fill region with random data to catch errors */
else
fill_random(romdata.regionbase, romdata.regionlength);
#endif
/* now process the entries in the region */
if (ROMREGION_ISROMDATA(region))
process_rom_entries(&romdata, region + 1);
else if (ROMREGION_ISDISKDATA(region))
process_disk_entries(&romdata, region + 1);
/* add this region to the list */
if (regiontype < REGION_MAX)
regionlist[regiontype] = region;
}
/* post-process the regions */
for (regnum = 0; regnum < REGION_MAX; regnum++)
if (regionlist[regnum])
{
debugload("Post-processing region %02X\n", regnum);
romdata.regionlength = memory_region_length(regnum);
romdata.regionbase = memory_region(regnum);
region_post_process(&romdata, regionlist[regnum]);
}
/* display the results and exit */
total_rom_load_warnings = romdata.warnings;
display_rom_load_results(&romdata);
}
void test_fft(size_t size, double time = 1.5)
{
const tick_value correction = 0;//calibrate_correction();
printf("> [%9ld, ", (long)size);
real* in = aligned_malloc<real>(size * 2);
real* out = aligned_malloc<real>(size * 2);
fill_random(in, size * 2);
std::copy(in, in + size * 2, out);
fft_benchmark<false> fft(size, out, out);
fft.execute();
fill_random(in, size * 2);
std::vector<tick_value> measures;
const tick_value bench_tick_start = tick();
const time_value bench_start = now();
while (time_between(now(), bench_start) < time)
{
const tick_value start = tick();
fft.execute();
const tick_value stop = tick();
const tick_value diff = stop - start;
measures.push_back(diff >= correction ? diff - correction : 0);
fill_random(in, size * 2);
dont_optimize(out);
std::copy(in, in + size * 2, out);
}
const tick_value bench_tick_stop = tick();
const time_value bench_stop = now();
const double tick_frequency =
(long double)(bench_tick_stop - bench_tick_start) / time_between(bench_stop, bench_start);
tick_value tick_value = get_minimum(measures);
double time_value = tick_value / tick_frequency;
const double flops = (5.0 * size * std::log((double)size) / (std::log(2.0) * time_value));
const char* units = "'s' ";
if (time_value < 0.000001)
{
units = "'ns'";
time_value = time_value * 1000000000.0;
}
else if (time_value < 0.001)
{
units = "'us'";
time_value = time_value * 1000000.0;
}
else if (time_value < 1.0)
{
units = "'ms'";
time_value = time_value * 1000.0;
}
printf("%9lld, ", tick_value);
printf("%7g, %s, ", time_value, units);
printf("%7g, ", flops / 1000000.0);
printf("%8lld, ", measures.size());
printf("%8.6f],\n", tick_frequency / 1000000000.0);
aligned_free(in);
aligned_free(out);
}
/*
* Implementation of the FFT tester described in
*
* Funda Ergün. Testing multivariate linear functions: Overcoming the
* generator bottleneck. In Proceedings of the Twenty-Seventh Annual
* ACM Symposium on the Theory of Computing, pages 407-416, Las Vegas,
* Nevada, 29 May--1 June 1995.
*/
void test_ergun(int n, fftw_direction dir, fftw_plan plan)
{
fftw_complex *inA, *inB, *inC, *outA, *outB, *outC;
fftw_complex *tmp;
fftw_complex impulse;
int i;
int rounds = 20;
FFTW_TRIG_REAL twopin = FFTW_K2PI / (FFTW_TRIG_REAL) n;
inA = (fftw_complex *) fftw_malloc(n * sizeof(fftw_complex));
inB = (fftw_complex *) fftw_malloc(n * sizeof(fftw_complex));
inC = (fftw_complex *) fftw_malloc(n * sizeof(fftw_complex));
outA = (fftw_complex *) fftw_malloc(n * sizeof(fftw_complex));
outB = (fftw_complex *) fftw_malloc(n * sizeof(fftw_complex));
outC = (fftw_complex *) fftw_malloc(n * sizeof(fftw_complex));
tmp = (fftw_complex *) fftw_malloc(n * sizeof(fftw_complex));
WHEN_VERBOSE(2,
printf("Validating plan, n = %d, dir = %s\n", n,
dir == FFTW_FORWARD ? "FORWARD" : "BACKWARD"));
/* test 1: check linearity */
for (i = 0; i < rounds; ++i) {
fftw_complex alpha, beta;
c_re(alpha) = DRAND();
c_im(alpha) = DRAND();
c_re(beta) = DRAND();
c_im(beta) = DRAND();
fill_random(inA, n);
fill_random(inB, n);
fftw_out_of_place(plan, n, inA, outA);
fftw_out_of_place(plan, n, inB, outB);
array_scale(outA, alpha, n);
array_scale(outB, beta, n);
array_add(tmp, outA, outB, n);
array_scale(inA, alpha, n);
array_scale(inB, beta, n);
array_add(inC, inA, inB, n);
fftw_out_of_place(plan, n, inC, outC);
array_compare(outC, tmp, n);
}
/* test 2: check that the unit impulse is transformed properly */
c_re(impulse) = 1.0;
c_im(impulse) = 0.0;
for (i = 0; i < n; ++i) {
/* impulse */
c_re(inA[i]) = 0.0;
c_im(inA[i]) = 0.0;
/* transform of the impulse */
outA[i] = impulse;
}
inA[0] = impulse;
for (i = 0; i < rounds; ++i) {
fill_random(inB, n);
array_sub(inC, inA, inB, n);
fftw_out_of_place(plan, n, inB, outB);
fftw_out_of_place(plan, n, inC, outC);
array_add(tmp, outB, outC, n);
array_compare(tmp, outA, n);
}
/* test 3: check the time-shift property */
/* the paper performs more tests, but this code should be fine too */
for (i = 0; i < rounds; ++i) {
int j;
fill_random(inA, n);
array_rol(inB, inA, n, 1, 1);
fftw_out_of_place(plan, n, inA, outA);
fftw_out_of_place(plan, n, inB, outB);
for (j = 0; j < n; ++j) {
FFTW_TRIG_REAL s = dir * FFTW_TRIG_SIN(j * twopin);
FFTW_TRIG_REAL c = FFTW_TRIG_COS(j * twopin);
c_re(tmp[j]) = c_re(outB[j]) * c - c_im(outB[j]) * s;
c_im(tmp[j]) = c_re(outB[j]) * s + c_im(outB[j]) * c;
}
array_compare(tmp, outA, n);
}
WHEN_VERBOSE(2, printf("Validation done\n"));
fftw_free(tmp);
fftw_free(outC);
fftw_free(outB);
fftw_free(outA);
fftw_free(inC);
fftw_free(inB);
fftw_free(inA);
}
int rom_load(const struct RomModule *romp)
{
const struct RomModule *regionlist[REGION_MAX];
const struct RomModule *region;
static struct rom_load_data romdata;
int regnum;
/* reset the region list */
for (regnum = 0;regnum < REGION_MAX;regnum++)
regionlist[regnum] = NULL;
/* reset the romdata struct */
memset(&romdata, 0, sizeof(romdata));
romdata.romstotal = count_roms(romp);
/* reset the disk list */
memset(disk_handle, 0, sizeof(disk_handle));
/* determine the correct biosset to load based on options.bios string */
system_bios = determine_bios_rom(Machine->gamedrv->bios);
/* loop until we hit the end */
for (region = romp, regnum = 0; region; region = rom_next_region(region), regnum++)
{
int regiontype = ROMREGION_GETTYPE(region);
debugload("Processing region %02X (length=%X)\n", regiontype, ROMREGION_GETLENGTH(region));
/* the first entry must be a region */
if (!ROMENTRY_ISREGION(region))
{
printf("Error: missing ROM_REGION header\n");
return 1;
}
/* if sound is disabled and it's a sound-only region, skip it */
if (Machine->sample_rate == 0 && ROMREGION_ISSOUNDONLY(region))
continue;
/* allocate memory for the region */
if (new_memory_region(regiontype, ROMREGION_GETLENGTH(region), ROMREGION_GETFLAGS(region)))
{
printf("Error: unable to allocate memory for region %d\n", regiontype);
return 1;
}
/* remember the base and length */
romdata.regionlength = memory_region_length(regiontype);
romdata.regionbase = memory_region(regiontype);
debugload("Allocated %X bytes @ %08X\n", romdata.regionlength, (int)romdata.regionbase);
/* clear the region if it's requested */
if (ROMREGION_ISERASE(region))
memset(romdata.regionbase, ROMREGION_GETERASEVAL(region), romdata.regionlength);
/* or if it's sufficiently small (<= 4MB) */
else if (romdata.regionlength <= 0x400000)
memset(romdata.regionbase, 0, romdata.regionlength);
#ifdef MAME_DEBUG
/* if we're debugging, fill region with random data to catch errors */
else
fill_random(romdata.regionbase, romdata.regionlength);
#endif
/* now process the entries in the region */
if (ROMREGION_ISROMDATA(region))
{
if (!process_rom_entries(&romdata, region + 1))
return 1;
}
else if (ROMREGION_ISDISKDATA(region))
{
if (!process_disk_entries(&romdata, region + 1))
return 1;
}
/* add this region to the list */
if (regiontype < REGION_MAX)
regionlist[regiontype] = region;
}
/* post-process the regions */
for (regnum = 0; regnum < REGION_MAX; regnum++)
if (regionlist[regnum])
{
debugload("Post-processing region %02X\n", regnum);
romdata.regionlength = memory_region_length(regnum);
romdata.regionbase = memory_region(regnum);
region_post_process(&romdata, regionlist[regnum]);
}
/* display the results and exit */
return display_rom_load_results(&romdata);
}
/* Same as test_ergun, but for multi-dimensional transforms: */
void testnd_ergun(int rank, int *n, fftw_direction dir, fftwnd_plan plan)
{
fftw_complex *inA, *inB, *inC, *outA, *outB, *outC;
fftw_complex *tmp;
fftw_complex impulse;
int N, n_before, n_after, dim;
int i, which_impulse;
int rounds = 20;
FFTW_TRIG_REAL twopin;
N = 1;
for (dim = 0; dim < rank; ++dim)
N *= n[dim];
inA = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex));
inB = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex));
inC = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex));
outA = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex));
outB = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex));
outC = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex));
tmp = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex));
WHEN_VERBOSE(2,
printf("Validating plan, N = %d, dir = %s\n", N,
dir == FFTW_FORWARD ? "FORWARD" : "BACKWARD"));
/* test 1: check linearity */
for (i = 0; i < rounds; ++i) {
fftw_complex alpha, beta;
c_re(alpha) = DRAND();
c_im(alpha) = DRAND();
c_re(beta) = DRAND();
c_im(beta) = DRAND();
fill_random(inA, N);
fill_random(inB, N);
fftwnd(plan, 1, inA, 1, N, outA, 1, N);
fftwnd(plan, 1, inB, 1, N, outB, 1, N);
array_scale(outA, alpha, N);
array_scale(outB, beta, N);
array_add(tmp, outA, outB, N);
array_scale(inA, alpha, N);
array_scale(inB, beta, N);
array_add(inC, inA, inB, N);
fftwnd(plan, 1, inC, 1, N, outC, 1, N);
array_compare(outC, tmp, N);
}
/*
* test 2: check that the unit impulse is transformed properly -- we
* need to test both the real and imaginary impulses
*/
for (which_impulse = 0; which_impulse < 2; ++which_impulse) {
if (which_impulse == 0) { /* real impulse */
c_re(impulse) = 1.0;
c_im(impulse) = 0.0;
} else { /* imaginary impulse */
c_re(impulse) = 0.0;
c_im(impulse) = 1.0;
}
for (i = 0; i < N; ++i) {
/* impulse */
c_re(inA[i]) = 0.0;
c_im(inA[i]) = 0.0;
/* transform of the impulse */
outA[i] = impulse;
}
inA[0] = impulse;
for (i = 0; i < rounds; ++i) {
fill_random(inB, N);
array_sub(inC, inA, inB, N);
fftwnd(plan, 1, inB, 1, N, outB, 1, N);
fftwnd(plan, 1, inC, 1, N, outC, 1, N);
array_add(tmp, outB, outC, N);
array_compare(tmp, outA, N);
}
}
/* test 3: check the time-shift property */
/* the paper performs more tests, but this code should be fine too */
/* -- we have to check shifts in each dimension */
n_before = 1;
n_after = N;
for (dim = 0; dim < rank; ++dim) {
int n_cur = n[dim];
n_after /= n_cur;
twopin = FFTW_K2PI / (FFTW_TRIG_REAL) n_cur;
for (i = 0; i < rounds; ++i) {
int j, jb, ja;
fill_random(inA, N);
array_rol(inB, inA, n_cur, n_before, n_after);
fftwnd(plan, 1, inA, 1, N, outA, 1, N);
fftwnd(plan, 1, inB, 1, N, outB, 1, N);
for (jb = 0; jb < n_before; ++jb)
for (j = 0; j < n_cur; ++j) {
FFTW_TRIG_REAL s = dir * FFTW_TRIG_SIN(j * twopin);
FFTW_TRIG_REAL c = FFTW_TRIG_COS(j * twopin);
for (ja = 0; ja < n_after; ++ja) {
c_re(tmp[(jb * n_cur + j) * n_after + ja]) =
c_re(outB[(jb * n_cur + j) * n_after + ja]) * c
- c_im(outB[(jb * n_cur + j) * n_after + ja]) * s;
c_im(tmp[(jb * n_cur + j) * n_after + ja]) =
c_re(outB[(jb * n_cur + j) * n_after + ja]) * s
+ c_im(outB[(jb * n_cur + j) * n_after + ja]) * c;
}
}
array_compare(tmp, outA, N);
}
n_before *= n_cur;
}
WHEN_VERBOSE(2, printf("Validation done\n"));
fftw_free(tmp);
fftw_free(outC);
fftw_free(outB);
fftw_free(outA);
fftw_free(inC);
fftw_free(inB);
fftw_free(inA);
}
void load_software_part_region(device_t &device, software_list_device &swlist, const char *swname, const rom_entry *start_region)
{
astring locationtag(swlist.list_name()), breakstr("%");
romload_private *romdata = device.machine().romload_data;
const rom_entry *region;
astring regiontag;
romdata->errorstring.reset();
romdata->softwarningstring.reset();
romdata->romstotal = 0;
romdata->romstotalsize = 0;
romdata->romsloadedsize = 0;
software_info *swinfo = swlist.find(swname);
if (swinfo != NULL)
{
UINT32 supported = swinfo->supported();
if (supported == SOFTWARE_SUPPORTED_PARTIAL)
{
romdata->errorstring.catprintf("WARNING: support for software %s (in list %s) is only partial\n", swname, swlist.list_name());
romdata->softwarningstring.catprintf("Support for software %s (in list %s) is only partial\n", swname, swlist.list_name());
}
if (supported == SOFTWARE_SUPPORTED_NO)
{
romdata->errorstring.catprintf("WARNING: support for software %s (in list %s) is only preliminary\n", swname, swlist.list_name());
romdata->softwarningstring.catprintf("Support for software %s (in list %s) is only preliminary\n", swname, swlist.list_name());
}
// attempt reading up the chain through the parents and create a locationtag astring in the format
// " swlist % clonename % parentname "
// open_rom_file contains the code to split the elements and to create paths to load from
locationtag.cat(breakstr);
while (swinfo != NULL)
{
locationtag.cat(swinfo->shortname()).cat(breakstr);
const char *parentname = swinfo->parentname();
swinfo = (parentname != NULL) ? swlist.find(parentname) : NULL;
}
// strip the final '%'
locationtag.del(locationtag.len() - 1, 1);
}
/* loop until we hit the end */
for (region = start_region; region != NULL; region = rom_next_region(region))
{
UINT32 regionlength = ROMREGION_GETLENGTH(region);
device.subtag(regiontag, ROMREGION_GETTAG(region));
LOG(("Processing region \"%s\" (length=%X)\n", regiontag.cstr(), regionlength));
/* the first entry must be a region */
assert(ROMENTRY_ISREGION(region));
/* if this is a device region, override with the device width and endianness */
endianness_t endianness = ROMREGION_ISBIGENDIAN(region) ? ENDIANNESS_BIG : ENDIANNESS_LITTLE;
UINT8 width = ROMREGION_GETWIDTH(region) / 8;
memory_region *memregion = romdata->machine().root_device().memregion(regiontag);
if (memregion != NULL)
{
if (romdata->machine().device(regiontag) != NULL)
normalize_flags_for_device(romdata->machine(), regiontag, width, endianness);
/* clear old region (todo: should be moved to an image unload function) */
romdata->machine().memory().region_free(memregion->name());
}
/* remember the base and length */
romdata->region = romdata->machine().memory().region_alloc(regiontag, regionlength, width, endianness);
LOG(("Allocated %X bytes @ %p\n", romdata->region->bytes(), romdata->region->base()));
/* clear the region if it's requested */
if (ROMREGION_ISERASE(region))
memset(romdata->region->base(), ROMREGION_GETERASEVAL(region), romdata->region->bytes());
/* or if it's sufficiently small (<= 4MB) */
else if (romdata->region->bytes() <= 0x400000)
memset(romdata->region->base(), 0, romdata->region->bytes());
#ifdef MAME_DEBUG
/* if we're debugging, fill region with random data to catch errors */
else
fill_random(romdata->machine(), romdata->region->base(), romdata->region->bytes());
#endif
/* update total number of roms */
for (const rom_entry *rom = rom_first_file(region); rom != NULL; rom = rom_next_file(rom))
{
romdata->romstotal++;
romdata->romstotalsize += rom_file_size(rom);
}
/* now process the entries in the region */
if (ROMREGION_ISROMDATA(region))
process_rom_entries(romdata, locationtag, region, region + 1, &device, TRUE);
else if (ROMREGION_ISDISKDATA(region))
process_disk_entries(romdata, core_strdup(regiontag.cstr()), region, region + 1, locationtag);
}
/* now go back and post-process all the regions */
for (region = start_region; region != NULL; region = rom_next_region(region))
{
device.subtag(regiontag, ROMREGION_GETTAG(region));
region_post_process(romdata, regiontag.cstr(), ROMREGION_ISINVERTED(region));
}
/* display the results and exit */
display_rom_load_results(romdata, TRUE);
}
void test_io_dbl()
{
int n, ndim = NDIM;
double err, tt0, tt1, mbytes;
int g_a, g_b, d_a;
int i, itmp, j, req, loop;
int glo[MAXDIM],ghi[MAXDIM];
dra_size_t dlo[MAXDIM],dhi[MAXDIM];
dra_size_t ddims[MAXDIM],reqdims[MAXDIM];
dra_size_t m;
int index[MAXDIM], dims[MAXDIM];
int me, nproc, isize;
double *ptr;
double plus, minus;
int ld[MAXDIM], chunk[MAXDIM];
char filename[80];
FILE *fd;
n = SIZE;
m = ((dra_size_t)NFACTOR)*((dra_size_t)SIZE);
loop = 1;
for (i=0; i<ndim; i++) loop *= NFACTOR;
req = -1;
nproc = GA_Nnodes();
me = GA_Nodeid();
if (me == 0) {
printf("Creating temporary global arrays %d",n);
for (i=1; i<ndim; i++) {
printf(" x %d",n);
}
printf("\n");
}
if (me == 0) fflush(stdout);
GA_Sync();
for (i=0; i<ndim; i++) {
dims[i] = n;
chunk[i] = 1;
}
g_a = NGA_Create(MT_DBL, ndim, dims, "a", chunk);
if (!g_a) GA_Error("NGA_Create failed: a", 0);
g_b = NGA_Create(MT_DBL, ndim, dims, "b", chunk);
if (!g_b) GA_Error("NGA_Create failed: b", 0);
if (me == 0) printf("done\n");
if (me == 0) fflush(stdout);
/* initialize g_a, g_b with random values
... use ga_access to avoid allocating local buffers for ga_put */
GA_Sync();
NGA_Distribution(g_a, me, glo, ghi);
NGA_Access(g_a, glo, ghi, &ptr, ld);
isize = 1;
for (i=0; i<ndim; i++) isize *= (ghi[i]-glo[i]+1);
fill_random(ptr, isize);
GA_Sync();
GA_Zero(g_b);
/*.......................................................................*/
if (me == 0) {
printf("Creating Disk array %ld",m);
for (i=1; i<ndim; i++) {
printf(" x %ld",m);
}
printf("\n");
}
if (me == 0) fflush(stdout);
for (i=0; i<ndim; i++) {
ddims[i] = m;
reqdims[i] = (dra_size_t)n;
}
GA_Sync();
strcpy(filename,FNAME);
if (! (fd = fopen(filename, "w"))) {
strcpy(filename,FNAME_ALT);
if (! (fd = fopen(filename, "w"))) {
GA_Error("open failed",0);
}
}
fclose(fd);
if (NDRA_Create(MT_DBL, ndim, ddims, "A", filename, DRA_RW,
reqdims, &d_a) != 0) {
GA_Error("NDRA_Create failed(d_a): ",0);
}
if (me == 0) printf("testing write\n");
fflush(stdout);
tt1 = 0.0;
for (i=0; i<loop; i++) {
itmp=i;
for (j=0; j<ndim; j++) {
index[j] = itmp%NFACTOR;
itmp = (itmp - index[j])/NFACTOR;
}
for (j=0; j<ndim; j++) {
glo[j] = 0;
ghi[j] = SIZE - 1;
dlo[j] = ((dra_size_t)index[j])*((dra_size_t)SIZE);
dhi[j] = (((dra_size_t)index[j])+(dra_size_t)1)
* ((dra_size_t)SIZE) - (dra_size_t)1;
}
tt0 = MP_TIMER();
if (NDRA_Write_section(FALSE, g_a, glo, ghi,
d_a, dlo, dhi, &req) != 0) {
GA_Error("ndra_write_section failed:",0);
}
if (DRA_Wait(req) != 0) {
GA_Error("DRA_Wait failed(d_a): ",req);
}
tt1 += (MP_TIMER() - tt0);
}
GA_Dgop(&tt1,1,"+");
tt1 = tt1/((double)nproc);
mbytes = 1.e-6 * (double)(pow(m,ndim)*sizeof(double));
if (me == 0) {
printf("%11.2f MB time = %11.2f rate = %11.3f MB/s\n",
mbytes,tt1,mbytes/tt1);
}
if (DRA_Close(d_a) != 0) {
GA_Error("DRA_Close failed(d_a): ",d_a);
}
if (me == 0) printf("\n");
if (me == 0) printf("disk array closed\n");
if (me == 0) fflush(stdout);
/*..........................................................*/
if (me == 0) printf("\n");
if (me == 0) printf("opening disk array\n");
if (DRA_Open(filename, DRA_R, &d_a) != 0) {
GA_Error("DRA_Open failed",0);
}
if (me == 0) printf("testing read\n");
/* printf("testing read on proc %d\n",me); */
if (me == 0) fflush(stdout);
tt1 = 0.0;
for (i=0; i<loop; i++) {
itmp=i;
for (j=0; j<ndim; j++) {
index[j] = itmp%NFACTOR;
itmp = (itmp - index[j])/NFACTOR;
}
for (j=0; j<ndim; j++) {
glo[j] = 0;
ghi[j] = SIZE - 1;
dlo[j] = ((dra_size_t)index[j])*((dra_size_t)SIZE);
dhi[j] = (((dra_size_t)index[j])+(dra_size_t)1)
* ((dra_size_t)SIZE) - (dra_size_t)1;
}
tt0 = MP_TIMER();
if (NDRA_Read_section(FALSE, g_b, glo, ghi,
d_a, dlo, dhi, &req) != 0) {
GA_Error("ndra_read_section failed:",0);
}
if (DRA_Wait(req) != 0) {
GA_Error("DRA_Wait failed(d_a): ",req);
}
tt1 += (MP_TIMER() - tt0);
plus = 1.0;
minus = -1.0;
GA_Add(&plus, g_a, &minus, g_b, g_b);
err = GA_Ddot(g_b, g_b);
if (err != 0) {
if (me == 0) {
printf("BTW, we have error = %f on loop value %d\n",
err,i);
}
GA_Error(" bye",0);
}
}
GA_Dgop(&tt1,1,"+");
tt1 = tt1/((double)nproc);
if (me == 0) {
printf("%11.2f MB time = %11.2f rate = %11.3f MB/s\n",
mbytes,tt1,mbytes/tt1);
}
if (DRA_Delete(d_a) != 0) GA_Error("DRA_Delete failed",0);
/*.......................................................................*/
GA_Destroy(g_a);
GA_Destroy(g_b);
}
void rom_load_manager::process_region_list()
{
std::string regiontag;
/* loop until we hit the end */
device_iterator deviter(machine().root_device());
for (device_t *device = deviter.first(); device != nullptr; device = deviter.next())
for (const rom_entry *region = rom_first_region(*device); region != nullptr; region = rom_next_region(region))
{
UINT32 regionlength = ROMREGION_GETLENGTH(region);
regiontag = rom_region_name(*device, region);
LOG(("Processing region \"%s\" (length=%X)\n", regiontag.c_str(), regionlength));
/* the first entry must be a region */
assert(ROMENTRY_ISREGION(region));
if (ROMREGION_ISROMDATA(region))
{
/* if this is a device region, override with the device width and endianness */
UINT8 width = ROMREGION_GETWIDTH(region) / 8;
endianness_t endianness = ROMREGION_ISBIGENDIAN(region) ? ENDIANNESS_BIG : ENDIANNESS_LITTLE;
if (machine().device(regiontag.c_str()) != nullptr)
normalize_flags_for_device(machine(), regiontag.c_str(), width, endianness);
/* remember the base and length */
m_region = machine().memory().region_alloc(regiontag.c_str(), regionlength, width, endianness);
LOG(("Allocated %X bytes @ %p\n", m_region->bytes(), m_region->base()));
/* clear the region if it's requested */
if (ROMREGION_ISERASE(region))
memset(m_region->base(), ROMREGION_GETERASEVAL(region), m_region->bytes());
/* or if it's sufficiently small (<= 4MB) */
else if (m_region->bytes() <= 0x400000)
memset(m_region->base(), 0, m_region->bytes());
#ifdef MAME_DEBUG
/* if we're debugging, fill region with random data to catch errors */
else
fill_random(m_region->base(), m_region->bytes());
#endif
/* now process the entries in the region */
process_rom_entries(device->shortname().c_str(), region, region + 1, device, FALSE);
}
else if (ROMREGION_ISDISKDATA(region))
process_disk_entries(regiontag.c_str(), region, region + 1, nullptr);
}
/* now go back and post-process all the regions */
for (device_t *device = deviter.first(); device != nullptr; device = deviter.next())
for (const rom_entry *region = rom_first_region(*device); region != nullptr; region = rom_next_region(region))
{
regiontag = rom_region_name(*device, region);
region_post_process(regiontag.c_str(), ROMREGION_ISINVERTED(region));
}
/* and finally register all per-game parameters */
for (device_t *device = deviter.first(); device != nullptr; device = deviter.next())
for (const rom_entry *param = rom_first_parameter(*device); param != nullptr; param = rom_next_parameter(param))
{
regiontag = rom_parameter_name(*device, param);
machine().parameters().add(regiontag, rom_parameter_value(param));
}
}
void test_in_place(int n, int istride,
int howmany, fftw_direction dir,
fftw_plan validated_plan, int specific)
{
fftw_complex *in2, *out2;
fftw_real *in1, *out1, *out3;
fftw_plan plan;
int i, j;
int ostride = istride;
int flags = measure_flag | wisdom_flag | FFTW_IN_PLACE;
if (coinflip())
flags |= FFTW_THREADSAFE;
in1 = (fftw_real *) fftw_malloc(istride * n * sizeof(fftw_real) * howmany);
in2 = (fftw_complex *) fftw_malloc(n * sizeof(fftw_complex));
out1 = in1;
out2 = (fftw_complex *) fftw_malloc(n * sizeof(fftw_complex));
out3 = (fftw_real *) fftw_malloc(n * sizeof(fftw_real));
if (!specific)
plan = rfftw_create_plan(n, dir, flags);
else
plan = rfftw_create_plan_specific(n, dir, flags,
in1, istride, out1, ostride);
CHECK(plan != NULL, "can't create plan");
/* generate random inputs */
fill_random(in1, n, istride);
for (j = 1; j < howmany; ++j)
for (i = 0; i < n; ++i)
in1[(j * n + i) * istride] = in1[i * istride];
/* copy random inputs to complex array for comparison with fftw: */
if (dir == FFTW_REAL_TO_COMPLEX)
for (i = 0; i < n; ++i) {
c_re(in2[i]) = in1[i * istride];
c_im(in2[i]) = 0.0;
} else {
int n2 = (n + 1) / 2;
c_re(in2[0]) = in1[0];
c_im(in2[0]) = 0.0;
for (i = 1; i < n2; ++i) {
c_re(in2[i]) = in1[i * istride];
c_im(in2[i]) = in1[(n - i) * istride];
}
if (n2 * 2 == n) {
c_re(in2[n2]) = in1[n2 * istride];
c_im(in2[n2]) = 0.0;
++i;
}
for (; i < n; ++i) {
c_re(in2[i]) = c_re(in2[n - i]);
c_im(in2[i]) = -c_im(in2[n - i]);
}
}
/*
* fill in other positions of the array, to make sure that
* rfftw doesn't overwrite them
*/
for (j = 1; j < istride; ++j)
for (i = 0; i < n * howmany; ++i)
in1[i * istride + j] = i * istride + j;
WHEN_VERBOSE(2, rfftw_print_plan(plan));
/* fft-ize */
if (howmany != 1 || istride != 1 || coinflip())
rfftw(plan, howmany, in1, istride, n * istride, 0, 0, 0);
else
rfftw_one(plan, in1, NULL);
rfftw_destroy_plan(plan);
/* check for overwriting */
for (j = 1; j < ostride; ++j)
for (i = 0; i < n * howmany; ++i)
CHECK(out1[i * ostride + j] == i * ostride + j,
"output has been overwritten");
fftw(validated_plan, 1, in2, 1, n, out2, 1, n);
if (dir == FFTW_REAL_TO_COMPLEX) {
int n2 = (n + 1) / 2;
out3[0] = c_re(out2[0]);
for (i = 1; i < n2; ++i) {
out3[i] = c_re(out2[i]);
out3[n - i] = c_im(out2[i]);
}
if (n2 * 2 == n)
out3[n2] = c_re(out2[n2]);
} else {
for (i = 0; i < n; ++i)
out3[i] = c_re(out2[i]);
}
for (j = 0; j < howmany; ++j)
CHECK(compute_error(out1 + j * n * ostride, ostride, out3, 1, n)
< TOLERANCE,
"test_in_place: wrong answer");
WHEN_VERBOSE(2, printf("OK\n"));
fftw_free(in1);
fftw_free(in2);
fftw_free(out2);
fftw_free(out3);
}