int calculate_distance_map (trajectory_frame *frame, void *p) {
unsigned int i, j;
unsigned int *nbodies = (unsigned int *) p;
distance_map *map = distance_map_alloc (*nbodies);
/* assign distance map to frame data */
frame->data = map;
/* calculate the distance map */
for (i=0; i<*nbodies; i++) {
for (j=i+1; j<*nbodies; j++) {
/* calculate the distance vector */
t_vector diff;
vector_diff (diff,
frame->body_i_state [i].r,
frame->body_i_state [j].r);
/* set the distance map */
set_distance_ij (i, j, vector_norm (diff), map);
}
}
/* print distance map for each frame */
print_distance_map (map);
return LOAD_TRAJ_FRAME_SUCCESS;
}
void verlet(const data* dat, output_function output)
{
int i;
const double dt = dat->eta * delta_t_factor; // konstant
vector *a = (vector*) malloc((dat->N)*sizeof(vector)),
*a_1 = (vector*) malloc((dat->N)*sizeof(vector)),
*r_p = (vector*) malloc((dat->N)*sizeof(vector)), // r_(n-1), not initialized
*r = init_r(dat), // r_(n)
*r_n = (vector*) malloc((dat->N)*sizeof(vector)), // r_(n+1), not initialized
*v = init_v(dat); // v_(n)
double time = 0;
output(time, dt, dat, r, v);
// set initial data
accelerations(dat, r, a); // a_0
adots(dat, r, v, a_1);
for (i = 0; i < dat->N; i++)
{
// set r_(-1)
r_p[i] = vector_add(r[i],
vector_add(scalar_mult(dt, v[i]),
scalar_mult(0.5 * dt * dt, a[i])));
// set r_1
r_n[i] = vector_add(scalar_mult(2, r[i]),
vector_add(scalar_mult(-1, r_p[i]),
scalar_mult(dt * dt, a[i])));
}
//time += dt;
// regular timesteps
while (time < dat->t_max)
{
accelerations(dat, r_n, a); // a_n+1 (gets shifted to a_n)
for (i = 0; i < dat->N; i++)
{
// shift indexes n+1 -> n
r_p[i] = r[i];
r[i] = r_n[i];
r_n[i] = vector_add(scalar_mult(2, r[i]),
vector_add(scalar_mult(-1, r_p[i]),
scalar_mult(dt * dt, a[i])));
v[i] = scalar_mult(0.5 / dt, vector_diff(r_n[i], r_p[i]));
}
adots(dat, r, v, a_1);
time += dt;
output(time, dt, dat, r, v);
}
free(a); free(r_p); free(r); free(r_n); free(v);
}
igraph_vector_t * ggen_analyze_longest_antichain(igraph_t *g)
{
/* The following steps are implemented :
* - Convert our DAG to a specific bipartite graph B
* - solve maximum matching on B
* - conver maximum matching to min vectex cover
* - convert min vertex cover to antichain on G
*/
int err;
unsigned long i,vg,found,added;
igraph_t b,gstar;
igraph_vector_t edges,*res = NULL;
igraph_vector_t c,s,t,todo,n,next,l,r;
igraph_eit_t eit;
igraph_es_t es;
igraph_integer_t from,to;
igraph_vit_t vit;
igraph_vs_t vs;
igraph_real_t value;
if(g == NULL)
return NULL;
/* before creating the bipartite graph, we need all relations
* between any two vertices : the transitive closure of g */
err = igraph_copy(&gstar,g);
if(err) return NULL;
err = ggen_transform_transitive_closure(&gstar);
if(err) goto error;
/* Bipartite convertion : let G = (S,C),
* we build B = (U,V,E) with
* - U = V = S (each vertex is present twice)
* - (u,v) \in E iff :
* - u \in U
* - v \in V
* - u < v in C (warning, this means that we take
* transitive closure into account, not just the
* original edges)
* We will also need two additional nodes further in the code.
*/
vg = igraph_vcount(g);
err = igraph_empty(&b,vg*2,1);
if(err) goto error;
/* id and id+vg will be a vertex in U and its copy in V,
* iterate over gstar edges to create edges in b
*/
err = igraph_vector_init(&edges,igraph_ecount(&gstar));
if(err) goto d_b;
igraph_vector_clear(&edges);
err = igraph_eit_create(&gstar,igraph_ess_all(IGRAPH_EDGEORDER_ID),&eit);
if(err) goto d_edges;
for(IGRAPH_EIT_RESET(eit); !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit))
{
err = igraph_edge(&gstar,IGRAPH_EIT_GET(eit),&from,&to);
if(err)
{
igraph_eit_destroy(&eit);
goto d_edges;
}
to += vg;
igraph_vector_push_back(&edges,(igraph_real_t)from);
igraph_vector_push_back(&edges,(igraph_real_t)to);
}
igraph_eit_destroy(&eit);
err = igraph_add_edges(&b,&edges,NULL);
if(err) goto d_edges;
/* maximum matching on b */
igraph_vector_clear(&edges);
err = bipartite_maximum_matching(&b,&edges);
if(err) goto d_edges;
/* Let M be the max matching, and N be E - M
* Define T as all unmatched vectices from U as well as all vertices
* reachable from those by going left-to-right along N and right-to-left along
* M.
* Define L = U - T, R = V \inter T
* C:= L + R
* C is a minimum vertex cover
*/
err = igraph_vector_init_seq(&n,0,igraph_ecount(&b)-1);
if(err) goto d_edges;
err = vector_diff(&n,&edges);
if(err) goto d_n;
err = igraph_vector_init(&c,vg);
if(err) goto d_n;
igraph_vector_clear(&c);
/* matched vertices : S */
err = igraph_vector_init(&s,vg);
if(err) goto d_c;
igraph_vector_clear(&s);
for(i = 0; i < igraph_vector_size(&edges); i++)
{
err = igraph_edge(&b,VECTOR(edges)[i],&from,&to);
if(err) goto d_s;
igraph_vector_push_back(&s,from);
}
/* we may have inserted the same vertex multiple times */
err = vector_uniq(&s);
if(err) goto d_s;
/* unmatched */
err = igraph_vector_init_seq(&t,0,vg-1);
if(err) goto d_s;
err = vector_diff(&t,&s);
if(err) goto d_t;
/* alternating paths
*/
err = igraph_vector_copy(&todo,&t);
if(err) goto d_t;
err = igraph_vector_init(&next,vg);
if(err) goto d_todo;
igraph_vector_clear(&next);
do {
vector_uniq(&todo);
added = 0;
for(i = 0; i < igraph_vector_size(&todo); i++)
{
if(VECTOR(todo)[i] < vg)
{
/* scan edges */
err = igraph_es_adj(&es,VECTOR(todo)[i],IGRAPH_OUT);
if(err) goto d_next;
err = igraph_eit_create(&b,es,&eit);
if(err)
{
igraph_es_destroy(&es);
goto d_next;
}
for(IGRAPH_EIT_RESET(eit); !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit))
{
if(igraph_vector_binsearch(&n,IGRAPH_EIT_GET(eit),NULL))
{
err = igraph_edge(&b,IGRAPH_EIT_GET(eit),&from,&to);
if(err)
{
igraph_eit_destroy(&eit);
igraph_es_destroy(&es);
goto d_next;
}
if(!igraph_vector_binsearch(&t,to,NULL))
{
igraph_vector_push_back(&next,to);
added = 1;
}
}
}
}
else
{
/* scan edges */
err = igraph_es_adj(&es,VECTOR(todo)[i],IGRAPH_IN);
if(err) goto d_next;
err = igraph_eit_create(&b,es,&eit);
if(err)
{
igraph_es_destroy(&es);
goto d_next;
}
for(IGRAPH_EIT_RESET(eit); !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit))
{
if(igraph_vector_binsearch(&edges,IGRAPH_EIT_GET(eit),NULL))
{
err = igraph_edge(&b,IGRAPH_EIT_GET(eit),&from,&to);
if(err)
{
igraph_eit_destroy(&eit);
igraph_es_destroy(&es);
goto d_next;
}
if(!igraph_vector_binsearch(&t,to,NULL))
{
igraph_vector_push_back(&next,from);
added = 1;
}
}
}
}
igraph_es_destroy(&es);
igraph_eit_destroy(&eit);
}
igraph_vector_append(&t,&todo);
igraph_vector_clear(&todo);
igraph_vector_append(&todo,&next);
igraph_vector_clear(&next);
} while(added);
err = igraph_vector_init_seq(&l,0,vg-1);
if(err) goto d_t;
err = vector_diff(&l,&t);
if(err) goto d_l;
err = igraph_vector_update(&c,&l);
if(err) goto d_l;
err = igraph_vector_init(&r,vg);
if(err) goto d_l;
igraph_vector_clear(&r);
/* compute V \inter T */
for(i = 0; i < igraph_vector_size(&t); i++)
{
if(VECTOR(t)[i] >= vg)
igraph_vector_push_back(&r,VECTOR(t)[i]);
}
igraph_vector_add_constant(&r,(igraph_real_t)-vg);
err = vector_union(&c,&r);
if(err) goto d_r;
/* our antichain is U - C */
res = malloc(sizeof(igraph_vector_t));
if(res == NULL) goto d_r;
err = igraph_vector_init_seq(res,0,vg-1);
if(err) goto f_res;
err = vector_diff(res,&c);
if(err) goto d_res;
goto ret;
d_res:
igraph_vector_destroy(res);
f_res:
free(res);
res = NULL;
ret:
d_r:
igraph_vector_destroy(&r);
d_l:
igraph_vector_destroy(&l);
d_next:
igraph_vector_destroy(&next);
d_todo:
igraph_vector_destroy(&todo);
d_t:
igraph_vector_destroy(&t);
d_s:
igraph_vector_destroy(&s);
d_c:
igraph_vector_destroy(&c);
d_n:
igraph_vector_destroy(&n);
d_edges:
igraph_vector_destroy(&edges);
d_b:
igraph_destroy(&b);
error:
igraph_destroy(&gstar);
return res;
}
void hermite_iterated(const data* dat, output_function output, int iterations)
{
int i,j;
double dt = dat->eta * delta_t_factor;
vector *a = (vector*) malloc((dat->N)*sizeof(vector)), // a_n, not initialized
*a_p = (vector*) malloc((dat->N)*sizeof(vector)), // a_(n+1)^p, not initialized
*a_1 = (vector*) malloc((dat->N)*sizeof(vector)), // a_1_n, not initialized
*a_1_p = (vector*) malloc((dat->N)*sizeof(vector)), // a_1_(n+1)^p, not initialized
*r = init_r(dat), // r_n
*r_p = (vector*) malloc((dat->N)*sizeof(vector)), // r_(n+1)^p, not initialized
*v = init_v(dat), // v_n
*v_p = (vector*) malloc((dat->N)*sizeof(vector)); // v_(n+1)^p, not initialized
double time = 0;
accelerations(dat, r, a);
adots(dat, r, v, a_1);
dt = delta_t(dat, a, a_1);
output(time, dt, dat, r, v);
while (time < dat->t_max)
{
// prediction step
for (i = 0; i < dat->N; i++)
{
v_p[i] = vector_add(v[i],
vector_add(scalar_mult(dt, a[i]),
scalar_mult(0.5 * dt * dt, a_1[i])));
r_p[i] = vector_add(r[i],
vector_add(scalar_mult(dt, v[i]),
vector_add(scalar_mult(0.5 * dt * dt, a[i]),
scalar_mult(dt * dt * dt / 6.0, a_1[i]))));
}
// iteration of correction step
for (j = 0; j < iterations; j++)
{
// predict a, a_1
accelerations(dat, r_p, a_p);
adots(dat, r_p, v_p, a_1_p);
for (i = 0; i < dat->N; i++)
{
// correction steps -> overwrite "prediction" variables for convenience,
// will get written in r,v after iteration is done
v_p[i] = vector_add(v[i],
vector_add(scalar_mult(dt / 2.0, vector_add(a_p[i], a[i])),
scalar_mult(dt * dt / 12.0, vector_diff(a_1_p[i], a_1[i]))));
r_p[i] = vector_add(r[i],
vector_add(scalar_mult(dt / 2.0, vector_add(v_p[i], v[i])),
scalar_mult(dt * dt / 12.0, vector_diff(a_p[i], a[i]))));
}
}
// apply iterated correction steps
for (i = 0; i < dat->N; i++)
{
r[i] = r_p[i];
v[i] = v_p[i];
}
time += dt;
// a/a_1 values for next step
accelerations(dat, r, a);
adots(dat, r, v, a_1);
// new dt
dt = delta_t(dat, a, a_1);
output(time, dt, dat, r, v);
}
free(a); free(a_p);
free(a_1); free(a_1_p);
free(r); free(r_p);
free(v); free(v_p);
}
void hermite(const data* dat, output_function output)
{
int i;
double dt = dat->eta * delta_t_factor;
vector *a = (vector*) malloc((dat->N)*sizeof(vector)), // a_n, not initialized
*a_p = (vector*) malloc((dat->N)*sizeof(vector)), // a_(n+1)^p, not initialized
*a_1 = (vector*) malloc((dat->N)*sizeof(vector)), // a_1_n, not initialized
*a_1_p = (vector*) malloc((dat->N)*sizeof(vector)), // a_1_(n+1)^p, not initialized
*a_2 = (vector*) malloc((dat->N)*sizeof(vector)), // a_(n+1)^(2), not initialized
*a_3 = (vector*) malloc((dat->N)*sizeof(vector)), // a_(n+1)^(3), not initialized
*r = init_r(dat), // r_n
*r_p = (vector*) malloc((dat->N)*sizeof(vector)), // r_(n+1)^p, not initialized
*v = init_v(dat), // v_n
*v_p = (vector*) malloc((dat->N)*sizeof(vector)); // v_(n+1)^p, not initialized
double time = 0;
accelerations(dat, r, a);
adots(dat, r, v, a_1);
dt = delta_t(dat, a, a_1);
output(time, dt, dat, r, v);
while (time < dat->t_max)
{
// prediction step
for (i = 0; i < dat->N; i++)
{
v_p[i] = vector_add(v[i],
vector_add(scalar_mult(dt, a[i]),
scalar_mult(0.5 * dt * dt, a_1[i])));
r_p[i] = vector_add(r[i],
vector_add(scalar_mult(dt, v[i]),
vector_add(scalar_mult(0.5 * dt * dt, a[i]),
scalar_mult(dt * dt * dt / 6.0, a_1[i]))));
}
// predict a^p, a_1^p
accelerations(dat, r_p, a_p);
adots(dat, r_p, v_p, a_1_p);
for (i = 0; i < dat->N; i++)
{
// predict 2nd and 3rd derivations
a_2[i] = vector_add(scalar_mult(2 * (-3) / dt / dt, vector_diff(a[i], a_p[i])),
scalar_mult(2 * (-1) / dt, vector_add(scalar_mult(2, a_1[i]), a_1_p[i])));
a_3[i] = vector_add(scalar_mult(6 * 2 / dt / dt / dt, vector_diff(a[i], a_p[i])),
scalar_mult(6 / dt / dt, vector_add(a_1[i], a_1_p[i])));
// correction steps
v[i] = vector_add(v_p[i],
vector_add(scalar_mult(dt * dt * dt / 6.0, a_2[i]),
scalar_mult(dt * dt * dt / 24.0, a_3[i])));
r[i] = vector_add(r_p[i],
vector_add(scalar_mult(dt * dt * dt * dt / 24.0, a_2[i]),
scalar_mult(dt * dt * dt * dt * dt / 120.0, a_3[i])));
}
time += dt;
// a/a_1 values for next step
accelerations(dat, r, a);
adots(dat, r, v, a_1);
// new dt
dt = delta_t_(dat, a, a_1, a_2, a_3);
output(time, dt, dat, r, v);
}
free(a); free(a_p);
free(a_1); free(a_1_p);
free(r); free(r_p);
free(v); free(v_p);
}
void lin_alg::gauss_seidel_solve(double **a, double *x, double *b, int n, int max_iter, bool &solved, double tol, double &error)
{
// Solve the system Ax=b by Gauss-Seidel iteration method
// R. Sheehan 3 - 8 - 2011
bool cgt=false;
double *oldx = vector(n);
double *diffx = vector(n);
int n_iter = 1;
double bi, mi, err;
while(n_iter<max_iter){
// store the initial approximation to the solution
for(int i=1; i<=n; i++){
oldx[i] = x[i];
}
// iteratively compute the solution vector x
for(int i=1; i<=n; i++){
bi=b[i];
mi=a[i][i];
for(int j=1; j<i; j++){
bi -= a[i][j]*x[j];
}
for(int j=i+1; j<=n; j++){
bi -= a[i][j]*oldx[j];
}
x[i] = bi/mi;
}
// test for convergence
// compute x - x_{old} difference between the two is the error
diffx = vector_diff(x, oldx, n, n);
// error is measured as the length of the difference vector ||x - x_{old}||_{\infty}
err = inf_norm(diffx, n);
if( n_iter%4 == 0){
cout<<"iteration "<<n_iter<<" , error = "<<err<<endl;
}
if(abs(err)<tol){ // solution has converged, stop iterating
cout<<"\nGauss-Seidel Iteration Complete\nSolution converged in "<<n_iter<<" iterations\n";
cout<<"Error = "<<abs(err)<<endl<<endl;
error=abs(err);
cgt=solved=true;
break;
}
n_iter++; // solution has not converged, keep iterating
}
if(!cgt){ // solution did not converge
cout<<"\nError: Gauss-Seidel Iteration\n";
cout<<"Error: Solution did not converge in "<<max_iter<<" iterations\n";
cout<<"Error = "<<abs(err)<<endl;
error=abs(err);
solved=false;
}
delete[] oldx;
delete[] diffx;
}
void lin_alg::jacobi_solve(double **a, double *x, double *b, int n, int max_iter, bool &solved, double tol, double &error)
{
// Solve the system Ax=b by Jacobi's iteration method
// This has the slowest convergence rate of the iterative techniques
// In practice you never use this algorithm
// Always use GS or SOR for iterative solution
// R. Sheehan 3 - 8 - 2011
bool cgt = false;
double *oldx = vector(n);
double *diffx = vector(n);
int n_iter = 1;
double bi, mi, err;
while(n_iter < max_iter){
// store the initial approximation to the solution
for(int i=1; i<=n; i++){
oldx[i] = x[i];
}
for(int i=1;i<=n;i++){
bi=b[i]; mi=a[i][i];
for(int j=1;j<=n;j++){
if(j!=i){
bi-=a[i][j]*oldx[j];
}
}
x[i]=bi/mi;
}
diffx = vector_diff(x, oldx, n, n);
err = inf_norm(diffx, n);
if( n_iter%4 == 0){
cout<<"iteration "<<n_iter<<" , error = "<<err<<endl;
}
if(abs(err)<tol){
cout<<"\nJacobi Iteration Complete\nSolution converged in "<<n_iter<<" iterations\n";
cout<<"Error = "<<abs(err)<<endl<<endl;
error = abs(err);
cgt = solved = true;
break;
}
n_iter++;
}
if(!cgt){
cout<<"\nError: Jacobi Iteration\n";
cout<<"Error: Solution did not converge in "<<max_iter<<" iterations\n\n";
}
delete[] oldx;
delete[] diffx;
}
