VerifyNetworks.h

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was auto-generated
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

#ifndef VERIFY_NETWORKS_H
#define VERIFY_NETWORKS_H

#include <inttypes.h>
#include <algorithm>
#include "ArrayHelpers.h"

namespace verification
{

int current_permutation = 0;
int current_2_pow_size = 1;

bool NextPermutation(int* arr, int size)
{
	//Gray Code Progression
	/**
	 * __asm__(
	 * 		"bsf %[perm],%[shift]\n\t"
	 * 		: [shift] "r"(shift)
	 * 		: [perm] "r"(current_permutation)
	 * )
	 * 
	 */
	++current_permutation;
	int shift = current_2_pow_size;
	int current;
	for (current = 0 ; current < size; ++current)
	{
		shift = shift >> 1;
		if (current_permutation % shift == 0)
		{
			arr[current] = !arr[current];
			return (current_permutation < current_2_pow_size);
		}
	}
	return false;
}

int Sum(int* arr, int arraySize)
{
	int result = 0;
	for (int i = 0; i < arraySize; i += 1)
	{
		result += arr[i];
	}
	return result;
}

bool VerifyNetwork(int size, void(*network)(int*,size_t))
{
	int* arr = (int*) malloc(sizeof(int) * size * 2);
	int* toSort = arr + size;
	int ones = 0;
	for (int index = 0; index < size; index += 1)
	{
		arr[index] = 0;
	}
	current_permutation = 0;
	current_2_pow_size = 1 << size; // pow(2, size)
	do
	{
		ones = Sum(arr, size);
		CopyArray(arr, toSort, size);
		network(toSort, size);
		if (__builtin_expect(!IsSorted(toSort, size) | ones != Sum(toSort, size), 0))
		{
			return false;
		}
	} while (NextPermutation(arr, size));

	return true;
}

template <typename Swap>
bool VerifySwap()
{
	SortableRef left;
	SortableRef right;

	uint64_t largerKey = 5;
	uint64_t largerKeyRef = 436862519;

	uint64_t smallerKey = 4;
	uint64_t smallerKeyRef = 436862520;

	left.key = largerKey;
	left.reference = largerKeyRef;
	// left.reference = 32;

	right.key = smallerKey;
	right.reference = smallerKeyRef;

	Swap::swap(left, right);
	if (left.key != smallerKey 
		|| left.reference != smallerKeyRef 
		|| right.key != largerKey 
		|| right.reference != largerKeyRef)
	{
		return false;
	}

	Swap::swap(left, right);
	if (left.key != smallerKey 
		|| left.reference != smallerKeyRef 
		|| right.key != largerKey 
		|| right.reference != largerKeyRef)
	{
		return false;
	}
	return true;
}

} // namespace verification

#endif // VERIFY_NETWORKS_H