/* Call this when robber is smelled, evidence found or robber
robbed a bank. Updates possible robber position. */
int cl_smell_robber (cop_knowledge_t *c, int mapindex, int dist, ptype_t coptype)
{
int *smell_range;
// dprintf ("cl_smell_robber at %d dist %d\n", mapindex, dist);
/* robber cannot occupy cop's pos .. */
smell_range = alloc_init_range (c);
set (smell_range, mapindex);
prp_without (c, smell_range);
if (coptype == PTYPE_COP_CAR) {
switch (dist) {
case 0:
smell_range = compute_range (c, mapindex, 1, coptype);
prp_without (c, smell_range);
free (smell_range);
break;
case 1:
smell_range = compute_range (c, mapindex, dist, coptype);
prp_and (c, smell_range);
free (smell_range);
break;
default:
dprintf ("Illegal smell distance for car cop: %d\n", dist);
exit (1);
}
} else {
switch (dist) {
case 0:
smell_range = compute_range (c, mapindex, 1, coptype);
prp_without (c, smell_range);
free (smell_range);
smell_range = compute_range (c, mapindex, 2, coptype);
prp_without (c, smell_range);
free (smell_range);
break;
case 1:
case 2:
smell_range = compute_range (c, mapindex, dist, coptype);
prp_and (c, smell_range);
free (smell_range);
break;
default:
dprintf ("Illegal smell distance for foot cop: %d\n", dist);
exit (1);
}
}
return c->prp_cnt[c->turn-1];
}
void solve_parallel(matrix *a, double *x, double *b, int nproc, int steps)
{
double w = 1.0;
double *it_vec = get_iterative_vector(a, w, b);
matrix upper = get_iterative_upper_matrix(a, w);
matrix lower = get_iterative_lower_matrix(a, w);
double *z = malloc(a->n*sizeof(*z));
for (int i = 1; i < nproc; i++)
send_matrix(upper, i);
for (int s = 0; s < steps; s++)
{
for (int i = 1; i < nproc; i++)
send_values(x, a->n, i);
range r = compute_range(a->n, nproc, 0);
mul_matrix_row(&upper, x, z, r.begin, r.end);
for (int i = 1; i < nproc; i++)
wait_for_results(z, a->n, nproc, i);
add_vector(z, it_vec, a->n);
forward_subst(&lower, x, z);
}
terminate_children(nproc);
}
int main(int argc, char *argv[])
{
#ifndef DEBUG
int nproc;
int rank;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (rank == 0)
{
FILE *fm = argc > 1 ? fopen(argv[1], "r") : fopen("matrixA.dat", "r");
FILE *fv = argc > 2 ? fopen(argv[2], "r") : fopen("vectorB.dat", "r");
int steps = argc > 3 ? atof(argv[3]) : 1;
matrix a = create_matrix_from_file(fm);
values b = create_vector_from_file(fv);
double *x = initialize_x(a.n, 0.0);
solve_parallel(&a, x, b.v, nproc, steps);
print_vector(x, a.n);
}
else
{
matrix m = receive_matrix();
double *z = malloc(m.n*sizeof(*z));
values v;
v.n = m.n;
v.v = malloc(v.n*sizeof(*v.v));
while (1) {
if (receive_vector(v) == exit_tag)
break;
range r = compute_range(v.n, nproc, rank);
mul_matrix_row(&m, v.v, z, r.begin, r.end);
MPI_Send(z+r.begin, r.end-r.begin, MPI_DOUBLE, 0, tag, MPI_COMM_WORLD);
}
}
MPI_Finalize();
#endif
#ifdef DEBUG
// test();
FILE *fm = argc > 1 ? fopen(argv[1], "r") : fopen("matrixA.dat", "r");
FILE *fv = argc > 2 ? fopen(argv[2], "r") : fopen("vectorB.dat", "r");
matrix m = create_matrix_from_file(fm);
values vector = create_vector_from_file(fv);
double *x = initialize_x(m.n, 0.0);
solve(&m, x, vector.v);
print_vector(x, m.n);
#endif
return 0;
}
/* Extract angle from the Message */
void can_proc_set_stop_msg( sCAN* mMsg )
{
if (mMsg->data[0] == 1)
{
EndPoint1.angle = extract_long_int( &(mMsg->data[1]) );
EndPoint1.value = extract_word ( &(mMsg->data[4]) );
} else {
EndPoint2.angle = extract_long_int( &(mMsg->data[1]) );
EndPoint2.value = extract_word ( &(mMsg->data[4]) );
}
order_stops_by_value();
compute_range();
save_cal();
}
/**********************************************************
read_stops_eeprom()
Reads both structures EndPoint1 & EndPoint2 from EEPROM,
and stores into the RAM.
***********************************************************/
byte* read_stops_eeprom(byte* addr)
{
// Save only EndPoint1 & EndPoint2
byte size = sizeof(sEndPoint);
byte* ptr = (byte*)&EndPoint1;
for (int i=0; i<size; i++)
*(ptr++) = eeprom_read_byte( addr++ );
ptr = (byte*)&EndPoint2;
for (int i=0; i<size; i++)
*(ptr++) = eeprom_read_byte( addr++ );
compute_range();
return addr;
}
void wait_for_results(double *z, int n, int nproc, int child_id)
{
MPI_Status status;
range r = compute_range(n, nproc, child_id);
MPI_Recv(z+r.begin, r.end-r.begin, MPI_DOUBLE, child_id, tag, MPI_COMM_WORLD, &status);
}
