int main(){
int data = 5;
int data2 = 6;
int data3 = 28;
int data4 = 15;
int data5 = 10;
char* strings[] = {"monday", "tuesday","wednesday","thursday","friday","saturday","sunday"};
linkedList list = NULL ;
//test with integers
list = LinkedList(list, sizeof(int), &compareInt, &printInt,0);
insert(list, &data);
insert(list,&data2);
printf("size: %d\n", getSize(list));
printf("found data position %d\n", contains(list, &data2));
delete(list, &data);
printf("found data position %d\n", contains(list, &data2));
printf("size: %d\n", getSize(list));
insert(list, &data3);
insert(list, &data4);
insert(list, &data5);
toString(list);
deAllocate(list);
// test with string, here we assume that the longest string had 20 characters.
list = LinkedList(list, 20, &compareStr, &printString,1);
for(int i = 0 ; i < 7; i++){
insert(list, strings[i]);
}
toString(list);
delete(list, "monday");
printf("size: %d\n", getSize(list));
delete(list,"friday"); //to bad jajaja
printf("found data position %d\n", contains(list, "tuesday"));
printf("\n\n");
toString(list);
deAllocate(list);
return 0;
}
/* Reorders eigenvectors so that they come with eigenvalues in *
* ascending order. A->M[i][i].real is also rearanged. */
void sort_eigenvectors(Matrix *A, Matrix *V)
{
register int N , i, j, k ;
register double fu ;
register double_complex *bu ;
double_complex *SaveTmp0 ;
Matrix Tmp ;
double *D;
N = A->N ;
Tmp = AllocateMatrix(N) ;
/* Make V->M[i] the i th eigenvector. *
* Otherwise V->M[][i] is the eigenvector which makes reordering costly */
HermitianConj(V, &Tmp) ;
/* extract the eigenvalues */
D = (double *) malloc(N*sizeof(double)) ;
for(i=0;i<N;i++)
D[i] = A->M[i][i].real ;
/* Save Tmp.M[0] so that we can deallocate the memory Tmp occuppies *
* The Value of Tmp.M[0] may change with sorting */
SaveTmp0 = Tmp.M[0] ;
for(i=0;i<N;i++)
for (j=1;j<N-i;j++)
{
k = j-1 ;
if(D[j]<D[k]) /* swicth them */
{
/* switch the eigenvalues */
fu = D[k] ;
D[k] = D[j] ;
D[j] = fu ;
/* switch the eigenvectors */
bu = Tmp.M[k] ;
Tmp.M[k] = Tmp.M[j] ;
Tmp.M[j] = bu ;
}
}
for(i=0;i<N;i++)
A->M[i][i].real = D[i];
free(D) ;
HermitianConj(&Tmp,V) ;
/*Restore the Tmp.M[0] for deallocation */
Tmp.M[0] = SaveTmp0 ;
deAllocate(&Tmp) ;
}
int
Kalkreuter_qdp(QDP_ColorVector **eigVec, double *eigVal, Real Tolerance,
Real RelTol, int Nvecs, int MaxIter, int Restart, int Kiters,
QDP_Subset subset)
{
QLA_Real max_error = 1.0e+10;
QLA_Real min_grad;
QLA_Real *grad, *err;
Matrix Array, V;
QDP_ColorVector *vec;
int total_iters=0;
int i, j;
int iter = 0;
#ifdef DEBUG
if(QDP_this_node==0) printf("begin Kalkreuter_qdp\n");
#endif
prepare_Matrix();
Array = AllocateMatrix(Nvecs); /* Allocate the array */
V = AllocateMatrix(Nvecs); /* Allocate the Eigenvector matrix */
vec = QDP_create_V();
grad = malloc(Nvecs*sizeof(QLA_Real));
err = malloc(Nvecs*sizeof(QLA_Real));
/* Initiallize all the eigenvectors to a random vector */
for(j=0; j<Nvecs; j++) {
grad[j] = 1.0e+10;
QDP_V_eq_gaussian_S(eigVec[j], rand_state, QDP_all);
eigVal[j] = 1.0e+16;
//project_out_qdp(eigVec[j], eigVec, j, subset);
//normalize_qdp(eigVec[j], subset);
}
#if 0
constructArray_qdp(eigVec, &Array, grad, subset);
Jacobi(&Array, &V, JACOBI_TOL);
sort_eigenvectors(&Array, &V);
RotateBasis_qdp(eigVec, &V, subset);
#endif
while( (max_error>Tolerance) && (iter<Kiters) ) {
iter++;
min_grad = grad[0]/eigVal[0];
for(i=1; i<Nvecs; i++) {
if(grad[i]<min_grad*eigVal[i]) min_grad = grad[i]/eigVal[i];
}
RelTol = 0.3;
for(j=0; j<Nvecs; j++) {
if(grad[j]>Tolerance*eigVal[j]) {
QLA_Real rt;
rt = RelTol*min_grad*eigVal[j]/grad[j];
//rt = 1e-5/grad[j];
if(rt>RelTol) rt = RelTol;
//rt = RelTol;
QDP_V_eq_V(vec, eigVec[j], QDP_all);
total_iters += Rayleigh_min_qdp(vec, eigVec, Tolerance, rt,
j, MaxIter, Restart, subset);
QDP_V_eq_V(eigVec[j], vec, QDP_all);
}
}
constructArray_qdp(eigVec, &Array, grad, subset);
for(i=0; i<Nvecs; i++)
node0_printf("quot(%i) = %g +/- %8e |grad|=%g\n",
i, Array.M[i][i].real, err[i], grad[i]);
#ifdef DEBUG
node0_printf("Eigenvalues before diagonalization\n");
for(i=0;i<Nvecs;i++)
node0_printf("quot(%i) = %g |grad|=%g\n",i,Array.M[i][i].real,grad[i]);
#endif
Jacobi(&Array, &V, JACOBI_TOL);
sort_eigenvectors(&Array, &V);
RotateBasis_qdp(eigVec, &V, subset);
constructArray_qdp(eigVec, &Array, grad, subset);
/* find the maximum error */
max_error = 0.0;
for(i=0; i<Nvecs; i++) {
err[i] = eigVal[i];
eigVal[i] = Array.M[i][i].real;
err[i] = fabs(err[i] - eigVal[i])/(1.0 - RelTol*RelTol);
if(eigVal[i]>1e-10) {
#ifndef STRICT_CONVERGENCE
if(err[i]/eigVal[i]>max_error) max_error = err[i]/eigVal[i];
#else
if(grad[i]/eigVal[i]>max_error) max_error = grad[i]/eigVal[i];
#endif
}
}
node0_printf("\nEigenvalues after diagonalization at iteration %i\n",iter);
for(i=0; i<Nvecs; i++)
node0_printf("quot(%i) = %g +/- %8e |grad|=%g\n",
i, eigVal[i], err[i], grad[i]);
}
node0_printf("BEGIN RESULTS\n");
for(i=0;i<Nvecs;i++){
node0_printf("Eigenvalue(%i) = %g +/- %8e\n",
i,eigVal[i],err[i]);
}
#if 0
node0_printf("BEGIN EIGENVALUES\n");
for(i=0; i<Nvecs; i++) {
double ev, er;
ev = sqrt(eigVal[i]);
er = err[i]/(2*ev);
node0_printf("%.8g\t%g\n", ev, er);
}
node0_printf("END EIGENVALUES\n");
{
QDP_Writer *qw;
QDP_String *md;
char evstring[100], *fn="eigenvecs.out";
md = QDP_string_create();
sprintf(evstring, "%i", Nvecs);
QDP_string_set(md, evstring);
qw = QDP_open_write(md, fn, QDP_SINGLEFILE);
for(i=0; i<Nvecs; i++) {
double ev, er;
ev = sqrt(eigVal[i]);
er = err[i]/(2*ev);
sprintf(evstring, "%.8g\t%g", ev, er);
QDP_string_set(md, evstring);
QDP_write_V(qw, md, eigVec[i]);
}
QDP_close_write(qw);
QDP_string_destroy(md);
}
#endif
/** Deallocate the arrays **/
deAllocate(&V) ;
deAllocate(&Array) ;
free(err);
free(grad);
QDP_destroy_V(vec);
cleanup_Matrix();
#ifdef DEBUG
if(QDP_this_node==0) printf("end Kalkreuter_qdp\n");
#endif
return total_iters;
}
