int main()
{
RadixSort sorter;
sorter.readList();
sorter.sort();
cout << "Output:\n";
sorter.printArray();
return 0;
}
/* Main Class */
int main(int argc, char *argv[]){
// Error-checking to make sure that error entered two arguements.
if(argc != 2) {
// Opening the text-file for the first time.
ifstream inFile(argv[1]);
// Instantiating Stack, and RadixSort class.
Stack *myStack = new Stack();
RadixSort myRadixSort;
int largestNumberInInt;
string tempString;
// Reading the data from the text-file as a string instead of integer.
// And changing it to int to get the largest value.
while(inFile >> tempString){
int tempInt = atoi(tempString.c_str());
if (tempInt > largestNumberInInt) {
largestNumberInInt = tempInt;
}
// Pushing each data in the text-file onto the stack.
myStack->push(tempString);
}
// Closing the text-file.
inFile.close();
// Opening the text-file, and passing it's reference whenever needed.
ofstream outFile(argv[2], std::ios_base::app);
// Printing out the final stack after all push.
myStack->printStack(outFile);
// Getting the total number of digits in the largest input.
myRadixSort.totalDigitFunction(largestNumberInInt);
// Popping the data from the stack, and adding it to the queue.
while(!(myStack->isStackEmpty())) {
string dataFromNode = myStack->pop();
// Before data can be added to the queue, we need to find the right index to add it to.
int digitNumber = myRadixSort.getDigit(dataFromNode);
int hashKey = myRadixSort.hashFunction(digitNumber);
// Inserting the data onto the queue.
myRadixSort.insertToCorrectTable(hashKey, dataFromNode);
}
// Making sure that we only "swap" the table after the second iteration.
int numberOfIteration = 1;
// Swapping the data from the new table to the old table.
while(myRadixSort.currentDigit < myRadixSort.totalDigit) {
myRadixSort.radixSortPrintFunction(outFile);
if(numberOfIteration != 1) {
myRadixSort.swapTableValues();
}
myRadixSort.changeTableCounts();
myRadixSort.changeDataToNewTable();
numberOfIteration++;
}
outFile.close();
} else {
int main()
{
int len = 28;
//scanf_s("%d", &len);
int p[28] = { 32, 103, 24, 88, 95, 70, 97, 15, 102, 6, 79, 46, 51, 37, 93, 108, 9, 58, 53, 58, 79, 36, 58, 91, 78, 58, 61, 81 };
RadixSort Radix;
Radix.radixSort(p, len);
//insert_sort(p, len);
for (int i = 0; i < len; i++)
{
printf("%d,", *(p + i));
}
scanf_s("%d", &len);
return 0;
}
void ParticleInitializer::depthSortEfficient(const vec3f& halfVector)
{
// calculate eye-space z
for (int32_t i = 0; i < getNumActive(); ++i)
{
float z = -dot(halfVector, truncate(m_pos[i])); // project onto vector
m_zs[i] = z;
}
// sort
m_sorter.Sort(m_zs, getNumActive());
const GLuint *sortedIndices32 = m_sorter.GetIndices();
for (int32_t i = 0; i < getNumActive(); ++i)
{
m_sortedIndices16[i] = (GLushort) sortedIndices32[i];
}
}
void RadixSortTests::testFloatList()
{
std::list<float> container;
FloatSortFunctor func;
RadixSort<std::list<float>, float, float> sorter;
for (int i = 0; i < 1000; ++i)
{
container.push_back((float)Math::RangeRandom(-1e10, 1e10));
}
sorter.sort(container, func);
std::list<float>::iterator v = container.begin();
float lastValue = *v++;
for (;v != container.end(); ++v)
{
CPPUNIT_ASSERT(*v >= lastValue);
lastValue = *v;
}
}
void RadixSortTests::testIntVector()
{
std::vector<int> container;
IntSortFunctor func;
RadixSort<std::vector<int>, int, int> sorter;
for (int i = 0; i < 1000; ++i)
{
container.push_back((int)Math::RangeRandom(-1e10, 1e10));
}
sorter.sort(container, func);
std::vector<int>::iterator v = container.begin();
int lastValue = *v++;
for (;v != container.end(); ++v)
{
CPPUNIT_ASSERT(*v >= lastValue);
lastValue = *v;
}
}
void RadixSortTests::testUnsignedIntList()
{
std::list<unsigned int> container;
UnsignedIntSortFunctor func;
RadixSort<std::list<unsigned int>, unsigned int, unsigned int> sorter;
for (int i = 0; i < 1000; ++i)
{
container.push_back((unsigned int)Math::RangeRandom(0, 1e10));
}
sorter.sort(container, func);
std::list<unsigned int>::iterator v = container.begin();
unsigned int lastValue = *v++;
for (;v != container.end(); ++v)
{
CPPUNIT_ASSERT(*v >= lastValue);
lastValue = *v;
}
}
// Compute the convex hull using Graham Scan.
void nv::convexHull(const Array<Vector2> & input, Array<Vector2> & output, float epsilon/*=0*/)
{
const uint inputCount = input.count();
Array<float> coords;
coords.resize(inputCount);
for (uint i = 0; i < inputCount; i++) {
coords[i] = input[i].x;
}
RadixSort radix;
radix.sort(coords);
const uint * ranks = radix.ranks();
Array<Vector2> top(inputCount);
Array<Vector2> bottom(inputCount);
Vector2 P = input[ranks[0]];
Vector2 Q = input[ranks[inputCount-1]];
float topy = max(P.y, Q.y);
float boty = min(P.y, Q.y);
for (uint i = 0; i < inputCount; i++) {
Vector2 p = input[ranks[i]];
if (p.y >= boty) top.append(p);
}
for (uint i = 0; i < inputCount; i++) {
Vector2 p = input[ranks[inputCount-1-i]];
if (p.y <= topy) bottom.append(p);
}
// Filter top list.
output.clear();
output.append(top[0]);
output.append(top[1]);
for (uint i = 2; i < top.count(); ) {
Vector2 a = output[output.count()-2];
Vector2 b = output[output.count()-1];
Vector2 c = top[i];
float area = triangleArea(a, b, c);
if (area >= -epsilon) {
output.popBack();
}
if (area < -epsilon || output.count() == 1) {
output.append(c);
i++;
}
}
uint top_count = output.count();
output.append(bottom[1]);
// Filter bottom list.
for (uint i = 2; i < bottom.count(); ) {
Vector2 a = output[output.count()-2];
Vector2 b = output[output.count()-1];
Vector2 c = bottom[i];
float area = triangleArea(a, b, c);
if (area >= -epsilon) {
output.popBack();
}
if (area < -epsilon || output.count() == top_count) {
output.append(c);
i++;
}
}
// Remove duplicate element.
nvDebugCheck(output.front() == output.back());
output.popBack();
}
void FaceOneRing::initVertices()
{
const uint edgeCount = m_face->edgeCount();
m_vertexArray.reserve(16);
// Add face vertices.
for (HalfEdge::Face::ConstEdgeIterator it(m_firstEdge); !it.isDone(); it.advance())
{
const HalfEdge::Edge * edge = it.current();
m_vertexArray.append(edge->from());
}
// @@ Add support for non manifold surfaces!
// The fix:
// - not all colocals should point to the same edge.
// - multiple colocals could belong to different boundaries, make sure they point to the right one.
// @@ When the face neighborhood wraps that could result in overlapping stencils.
// Add surronding vertices.
for (HalfEdge::Face::ConstEdgeIterator it(m_firstEdge); !it.isDone(); it.advance())
{
const HalfEdge::Edge * firstEdge = it.current();
const HalfEdge::Vertex * vertex = firstEdge->from();
const uint valence = vertex->valence();
uint i = 0;
// Traverse edges around vertex
for (HalfEdge::Vertex::ReverseConstEdgeIterator eit(firstEdge); !eit.isDone(); eit.advance(), i++)
{
const HalfEdge::Edge * edge = eit.current();
nvCheck(edge->from()->pos() == vertex->pos());
appendVertex(edge->to());
if (edge->face() != NULL)
{
appendVertex(edge->next()->to());
}
}
nvDebugCheck(i == valence);
}
const uint vertexCount = m_vertexArray.count();
// @@ You can only sort by id when the vertices do not have colocals.
#if 0
// Sort vertices by id. Create index array per patch.
Array<uint> vertexIdArray;
vertexIdArray.resize(vertexCount);
for (uint v = 0; v < vertexCount; v++)
{
vertexIdArray[v] = m_vertexArray[v]->id();
}
RadixSort radix;
radix.sort(vertexIdArray);
#else
// Sort vertices lexycographically. Create index array per patch.
Array<float> vertexXArray;
Array<float> vertexYArray;
Array<float> vertexZArray;
vertexXArray.resize(vertexCount);
vertexYArray.resize(vertexCount);
vertexZArray.resize(vertexCount);
for (uint v = 0; v < vertexCount; v++)
{
vertexXArray[v] = m_vertexArray[v]->pos().x();
vertexYArray[v] = m_vertexArray[v]->pos().y();
vertexZArray[v] = m_vertexArray[v]->pos().z();
}
RadixSort radix;
radix.sort(vertexXArray).sort(vertexYArray).sort(vertexZArray);
#endif
m_vertexIndexArray.resize(vertexCount);
const uint * indices = radix.ranks();
for (uint v = 0; v < vertexCount; v++)
{
m_vertexIndexArray[v] = indices[v];
}
}
