unsigned long int jsort() {
unsigned long int* aux;
aux = GC_malloc(SIZE, sizeof(unsigned long int) );
int i;
for(i = 0; i < SIZE; i++) {
aux[i] = J( i );
}
return insort( aux )[0];
}
void mergesort(int a[], int n)
{
/* Use insertion sort for small values */
if(n < 10)
insort(a,n);
else {
mergesort(a, n/2);
mergesort(a+n/2+1, n-n/2-1);
merge(a,n/2,a+n/2+1,n-n/2-1);
}
}
/**
* @brief Find the largest interval of projection coordinates
if the interval is large then VAC_SPACE.
If we can find any one are satified in the i dierction,
then
vac[i][0]= 0
vac[i][1]= 0
* @param pos
* @param vac (Direct Coordinates)
*/
void FindVac( POSCAR* pos, double vac[3][2])
{
int i,j,v;
double post;
double len[3];
double *interval=NULL;
double max_interval=-1;
POSCAR* posTmp=NULL;
/*Init*/
for (i=0; i<3; i++)
for (j=0; j<2; j++)
vac[i][j]=0;
POSCAR_Copy(pos, posTmp);
POSCAR_C2D(posTmp);
POSCAR_Confined(posTmp);
for (i=0; i<3; i++)
{
len[i]= dot3D(posTmp->lat->a[i], posTmp->lat->a[i]);
len[i]= sqrt(len[i]);
}
interval= malloc(sizeof(double)*posTmp->natom);
if (interval==NULL)
{
fprintf(stderr, "POSCAR_FindVac: Memory Allocate Error.\n");
exit(1);
}
for (v=0; v<3; v++)
{
insort(&(posTmp->atom_pos[0][0]), posTmp->natom, 3, v, false);
for (i=0; i<posTmp->natom; i++)
{
if (i==posTmp->natom-1)
post= posTmp->atom_pos[0][v]+1.0;
else
post= posTmp->atom_pos[i+1][v];
interval[i]=(post-posTmp->atom_pos[i][v])*len[v];
if (interval[i]>max_interval && interval[i]>VAC_SPACE)
{
vac[v][0]= posTmp->atom_pos[i][v];
vac[v][1]= post;
}
}
}
free(interval);
POSCAR_Free(posTmp);
}
int main(void)
{
int arr[MAX],num_of_ele;
num_of_ele=fillarr(arr);
puts("Original list");
showarr(arr,num_of_ele);
insort(arr,num_of_ele);
puts("Sorted list");
showarr(arr,num_of_ele);
puts("Done");
return 0;
}
int
main(void)
{
int i;
plan_tests(2);
{
double init[16] = { 29, 16, 25, 14, 21, 12, 17, 10,
13, 8, 9, 6, 5, 4, 1, 2 }, expect[16], actual[16];
dumpd(init, "unsorted");
double t0 = tick();
for (i = 0; i < LOOPS; ++i) {
memcpy(expect, init, sizeof(init));
qsort(expect, 16, sizeof(double), (cmpfn_t)cmpd);
}
double t1 = tick();
dumpd(expect, "sorted");
double t2 = tick();
for (i = 0; i < LOOPS; ++i) {
memcpy(actual, init, sizeof(init));
insort(actual);
}
double t3 = tick();
for (i = 0; i < LOOPS; ++i) {
memcpy(actual, init, sizeof(init));
ssesort16d(actual);
}
int j, rank[16];
double work[16];
double t4 = tick();
for (i = 0; i < LOOPS; ++i) {
memcpy(work, init, sizeof(init));
sserank16d(work, rank);
for (j = 0; j < 16; ++j) actual[j] = init[rank[j]];
}
double t5 = tick();
if (!ok(!memcmp(actual, expect, sizeof(actual)), "sserank output is sorted"))
dumpd(actual, "actual");
if (!ok(!memcmp(actual, work, sizeof(actual)), "ssesort output is sorted"))
dumpd(actual, "actual");
fprintf(stderr, "x %d: qsort: %.4f insertion: %.4f ssesort: %.4f sserank: %.4f\n",
LOOPS, t1 - t0, t3 - t2, t4 - t3, t5 - t4);
}
return exit_status();
}
int main(void)
{
int a[11],i;
printf("Please input ten number:\n");
for(i=1;i<11;i++)
scanf("%d",&a[i]);
for(i=1;i<11;i++)
printf("%d ",a[i]);
putchar('\n');
insort(a,10);
for(i=1;i<11;i++)
printf("%d ",a[i]);
putchar('\n');
return 0;
}
static int
gather(int nextpos, int nparts, PARTNO const *partv,
PART const *pdata, RANGE * dstv)
{
int ndsts = 0, i, curr;
for (i = nparts; --i >= 0;) {
for (curr = partv[i]; curr;) {
RANGE *rngp = pdata[curr].rng;
RSREC **rpp = rngp->omega, **omega;
do {
*--rpp = pdata[curr].rec;
curr = pdata[curr].next;
} while (pdata[curr].rng == rngp);
omega = rpp;
while (KEYLENG(*rpp) <= nextpos && ++rpp < rngp->omega);
int count = rngp->omega - rpp;
if (count >= MINRANGE) {
dstv[ndsts++] = (RANGE) {
rpp, rngp->omega};
DIAG_NRECS(_nrecs + count);
}
else if (count > 1 && KEYLENG(*rpp) > nextpos) {
insort(rpp, rngp->omega, nextpos);
}
rngp->omega = omega;
}
}
return ndsts;
}
CRSIndexMatrix::CRSIndexMatrix(IndexVector &row, IndexVector &col, IndexVector &values){
int idx, rowidx, datalen, rowdiff, offset, length=row.length();
/* *** determine number of rows and cols */
int nRow=0,nCol=0;
for(int k=0;k<length;k++){
if(row(k)>nRow) nRow=row(k);
if(col(k)>nCol) nCol=col(k);
}
nRow+=1;
nCol+=1; /* row and col index start with 0... */
/* *** initialize temporary variables */
int* data = new int[length];
int* colindex = new int[length];
int* rowptr = new int[nRow+1];
int* rowoff = new int[nRow];
memset(rowptr,0,(nRow+1)*sizeof(int));
/* *** create rowptr */
for(int k=0 ; k<length ; k++){
rowptr[row(k)+1]++;
}
for(int k=1 ; k<nRow ; k++){
rowptr[k+1] = rowptr[k+1]+rowptr[k];
}
memcpy(rowoff,rowptr,nRow*sizeof(int));
/* *** copy column index and values */
for(int k=0;k<length;k++){
idx = rowoff[ row(k) ];
rowoff[row(k) ]++;
data[idx] = values(k);
colindex[idx] = col(k);
}
/* *** sort values of each row */
for(int k=0;k<nRow;k++){
if(rowptr[k+1]>rowptr[k] ){
insort(colindex+rowptr[k],data+rowptr[k],rowptr[k+1]-rowptr[k]);
}
}
/* *** sum up entries with same indices and compress the data structures */
idx=0; rowidx=0; rowdiff=0;
for(int k=0;k<length;){
while(rowptr[rowidx+1]==k){
rowidx++;
rowptr[rowidx]-=rowdiff;
}
/* *** sum upp values with similar row and column indices */
offset=1;
while(k+offset < rowptr[rowidx+1] && colindex[k] == colindex[k+offset]){
data[k] += data[k+offset];
offset+=1;
}
if(data[k] != 0){
data[idx] = data[k] ;
colindex[idx] = colindex[k];
idx++;
rowdiff+=(offset-1);
}else{
/* *** ignore values that are 0 */
rowdiff+=offset;
}
k+=offset;
}
datalen=idx;
for(int k=rowidx+1;k<nRow+1;k++)
rowptr[k]= datalen;
/* *** set private variables */
_data = new int[datalen];
memcpy(_data, data, datalen*sizeof(int) );
_colindex = new int[datalen];
memcpy(_colindex, colindex, datalen*sizeof(int) );
_rowptr = rowptr;
_cols = nCol;
_rows = nRow;
_nonZeros = datalen;
delete []data;
delete []colindex;
}
unsigned long int tsort() {
return insort( T() )[0];
}
void run(int col) {
compute(col);
printf("\nBUFFER = %d\n", BUFF);
printf("COLUMNS = %d\n", COLS);
printf("ROWS = %d\n", ROWS);
printf("FULL = %d\n", FULL);
printf("END = %d\n", END);
printf("SIZE = %d\n\n", SIZE);
int *array = allocate(FULL);
printf("\n");
init_data(array);
if(toPr) {
printf("\nINITIAL LIST WITH BUFFER\n");
shiftUp();
print(array);
shiftDown();
}
printf("\n\nSTEP 1: Sort: ");
//STEP 1
if(nThreads > 1) psort(array, nThreads); //Sort using parallel insertion sort
else insort(array); //Sort using serial insertion sort
if(toPr) print(array);
printf("\nSTEP 2: Transpose Up: ");
//STEP 2
array = transposeUp(array);
if(toPr) print(array);
printf("\nSTEP 3: Sort: ");
//STEP 3
if(nThreads > 1) psort(array, nThreads); //Sort using parallel insertion sort
else insort(array); //Sort using serial insertion sort
if(toPr) print(array);
printf("\nSTEP 4: Transpose Down: ");
//STEP 4
array = transposeDown(array);
if(toPr) print(array);
printf("\nSTEP 5: Sort: ");
//STEP 5
if(nThreads > 1) psort(array, nThreads); //Sort using parallel insertion sort
else insort(array); //Sort using serial insertion sort
if(toPr) print(array);
printf("\nSTEP 6: Shift Up: ");
//STEP 6
shiftUp();
if(toPr) print(array);
printf("\nSTEP 7: Sort: ");
//STEP 7
if(nThreads > 1) psort(array, nThreads); //Sort using parallel insertion sort
else insort(array); //Sort using serial insertion sort
if(toPr) print(array);
printf("\nSTEP 8: Shift Down: ");
//STEP 8
shiftDown();
if(toPr) print(array);
printf("\n");
if(isSorted(array)){
printf("Array is sorted!\n\n");
} else {
printf("Array not sorted!\n\n");
}
free(array);
}
pwr_tInt32 GetOldestEvents(pwr_tUInt32 *nrOfEvents , pwr_tUInt32 *nrOfKeys)
{
sKey *tmpData;
pwr_tInt32 ret;
DBT data, key;
DBC *dbcp;
pwr_tUInt32 evCount = 0;
pwr_tUInt32 tmp = 0;
dbcp = NULL;
/* Acquire a cursor for the database. */
if ((ret = dataBaseP->cursor(dataBaseP, NULL, &dbcp, 0)) != 0)
{
errh_Error("error dataBaseP->cursor: %s\n", db_strerror(ret));
return RT_ELOG_UNKNOWN_ERROR;
}
/* Initialize the key/data return pair. */
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
/*Get the first event*/
if((ret = dbcp->c_get(dbcp, &key, &data, DB_FIRST)) != 0)
{
*nrOfEvents = 0;
return RT_ELOG_DB_EMPTY;
}
evCount++;
tmpData = (sKey *)key.data;
newlink(&lanklank);
putlink(*tmpData, lanklank);
insort(lanklank, listhead, &compTime);
tmp++;
while((ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0)
{
evCount++;
tmpData = (sKey *)key.data;
newlink(&lanklank);
putlink(*tmpData, lanklank);
insort(lanklank, listhead, &compTime);
tmp++;
if(nrlinks(listhead) > KEY_ARRAY_SIZE)
{
tmp--;
lanklank = lastlink(listhead);
elimlink(&lanklank);
}
}
if(ret != DB_NOTFOUND)
{
errh_Error("Error dbcp->c_get(DB_NEXT): %s\n", db_strerror(ret));
return RT_ELOG_UNKNOWN_ERROR;
}
/*Close the cursor*/
if((ret = dbcp->c_close(dbcp)) != 0)
{
errh_Error("Error dbcp_oldest->c_close(): %s\n", db_strerror(ret));
}
*nrOfEvents = evCount;
*nrOfKeys = tmp;
return RT_ELOG_OK;
}
