Dopo 3 giorni di prove mi arrendo...
Il programma calcola le posizioni di 4 stelle che sono disposte in modo simmetrico in un immaginario piano cartesiano 2D. Il fatto è che disposte in questo mode le 4 stelle dovrebbero conservare, teoricamente la loro simmetria sia nelle posizioni, sia nelle velocità sia nelle accelerazioni...

Invece che succede? Il programma sbaglia il calcolo, piano piano sclera...
E nn è che sbaglia di tanto (come se mi fossi scordato di considerare una stella o di aggiornare una variabile...), sbaglia all'ultima cifra decimale!!

Vi posto il codice... Io mi vado uccidere

codice:
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//#include <iostream>

#define G		6.6725985E-11				// Costante di gravitazione universale
#define TI		20	
using namespace std;

class Vect
{
public:
	double x, y, module;
};

class Bodies
{
public:
	double mass;
	Vect acc;
	Vect pos;
	Vect vel;
};

class Universe
{
public:
	int n;
	Bodies * body;
};

Universe * u;


void loop ( )
{
	int i, j;

	// Calcolo delle accelerazioni
	Vect dist;
	if ( u->n != 1 ) {
		for ( i = 0; i < u->n; i++ ) {
			u->body[i].acc.x = u->body[i].acc.y = 0;
			dist.x = dist.y = 0;
			for ( j = 0; j < u->n; j++ ) {
				if ( j != i ) {
					dist.x = u->body[i].pos.x - u->body[j].pos.x;
					dist.y = u->body[i].pos.y - u->body[j].pos.y;
					dist.module = sqrt ( dist.x * dist.x + dist.y * dist.y );
					if ( dist.module != 0 ) {
						u->body[i].acc.x -= u->body[j].mass * G * dist.x / 
								( dist.module * dist.module * dist.module );
						u->body[i].acc.y -= u->body[j].mass * G * dist.y / 
								( dist.module * dist.module * dist.module );
					}
				}
			}
		}
	}

	// Controlli anti-sclero
	printf ( "[0].acc.x = %.18lf\n[1].acc.x = %.18lf\n[2].acc.y = %.18lf\n[3].acc.y = %.18lf\n",
			 u->body[0].acc.x, -u->body[1].acc.x, u->body[2].acc.y, -u->body[3].acc.y );
	printf ( "[0].acc.y = %.18lf\n[1].acc.y = %.18lf\n[2].acc.x = %.18lf\n[3].acc.x = %.18lf\n",
			 u->body[0].acc.y, -u->body[1].acc.y, -u->body[2].acc.x, u->body[3].acc.x );
	system ("Pause");
	// Fine Controlli
	
	for ( i = 0; i < u->n; i++ ) {
		u->body[i].pos.x += u->body[i].vel.x * TI + u->body[i].acc.x * TI * TI / 2;
		u->body[i].pos.y += u->body[i].vel.y * TI + u->body[i].acc.y * TI * TI / 2;
		u->body[i].vel.x += u->body[i].acc.x * TI;
		u->body[i].vel.y += u->body[i].acc.y * TI;
	}
}

int main ( ) 
{
	u = new Universe;

	u->n = 4;
	u->body = new Bodies [u->n];

	u->body[0].mass = 2E+30;
	u->body[0].pos.x = - 1E+10;
	u->body[0].pos.y = 0;
	u->body[0].vel.x = 0;
	u->body[0].vel.y = -100000;
	
	u->body[1].mass = 2E+30;
	u->body[1].pos.x = 1E+10;
	u->body[1].pos.y = 0;
	u->body[1].vel.x = 0;
	u->body[1].vel.y = 100000;
	
	u->body[2].mass = 2E+30;
	u->body[2].pos.x = 0;
	u->body[2].pos.y = - 1E+10;
	u->body[2].vel.x = 100000;
	u->body[2].vel.y = 0;
	
	u->body[3].mass = 2E+30;
	u->body[3].pos.x = 0;
	u->body[3].pos.y = 1E+10;
	u->body[3].vel.x = -100000;
	u->body[3].vel.y = 0;
	
	for ( int i = 0; i < 1; ) 
	{
		loop ( );
	}
	
	system ("Pause");
	return 0;
}