star.c

#include <math.h>

#include "star.h"


/* * * * * * * * * * * * * * * * *
* 						    	 *
*        --- FONCTIONS ---       *
*								 *
* * * * * * * * * * * * * * * * */

Star* new_star_vel(Vector new_pos, Vector new_speed, Vector new_acc, double new_mass, double new_dt) {

	Star* new_star = malloc(sizeof(Star));

	new_star -> pos = new_pos;
	new_star -> acc = new_acc;
	new_star -> mass = new_mass;


	// copie mais en pointeur de speed
	Vector* p_speed = new_vec(new_speed.x , new_speed.y);
	// est-ce que c'est égal à &new_speed ? 

	// on multiplie le vecteur speed par delta_t (qui retourne un pointeur sur vecteur, que l'on déréférence) 
	Vector* pos_tmp = mul_vec(p_speed, new_dt);
	new_star -> previous_pos = *pos_tmp;
	free(pos_tmp);
	free(p_speed);



	// copie mais en pointeur de previous_pos
	Vector* p_pre_pos = new_vec(new_star -> previous_pos.x, new_star -> previous_pos.y);
	// copie mais en pointeur de pos
	Vector* p_pos = new_vec(new_star -> pos.x, new_star -> pos.y);

	// et on soustrait ce résultat au vecteur position (qui retourne un pointeur sur vecteur, que l'on déréférence)
	pos_tmp = sub_vec(p_pre_pos, p_pos);
	new_star -> previous_pos = *pos_tmp;
	free(pos_tmp);
	free(p_pre_pos);
	free(p_pos);

	pos_tmp = NULL;


	return new_star;
}


void reset_acc(Star* star) {
	Vector vec_null;
	vec_null.x = 0.0;
	vec_null.y = 0.0;

	star -> acc = vec_null;
}


void update_acc(Star* target, const Star* const s2) {
	Vector* rj_ri = sub_vec(&(s2 -> pos), &(target -> pos));
	int G_mi_mj = FORCE_GRAVITATION * target -> mass * s2 -> mass;
	Vector* temp = mul_vec(rj_ri, G_mi_mj);
	
	target -> acc = *mul_vec(temp, (1 / pow(norm(rj_ri), 3)));

	free(rj_ri);
	free(temp);
}


void update_pos_star(Star* star, double delta_t) {
	// new_position = (2 * pos) - previous_pos + (acc * delta_t * delta_t)
	star -> pos = *(mul_vec(&(star -> pos), 2));
	star -> pos = *(sub_vec(&(star -> pos), &(star -> previous_pos)));
	star -> pos = *(add_vec(&(star -> pos), mul_vec(&(star -> acc), delta_t * delta_t)));
}


void print_star(const Star* const star) {
	printf("\tprint_star() : \tposition = (%f ; %f) \n\t\t \
		position precedente = (%f ; %f) \n\t\t \
		acceleration = (%f ; %f) \n\t\t \
		masse = %f \n", star -> pos.x, star -> pos.y, star -> previous_pos.x, star -> previous_pos.y, star -> acc.x, star -> acc.y, star -> mass);
}



int random_mass() {
	return MASSE_MIN + (random_10() * MASSE_SOLAIRE);
}


Vector random_position() {
	// R * (math.log(1 - random_1()) / 1.8) * chaque composante du vecteur v(0.5 - random_1() ; 0.5 - random_1()) 
	// où R = math.pow(10, 18) [m] et R(0) est R(0) un nombre aléatoire entre 0 et 1
	
	Vector position;
	double temp = 1e18 * (log(1 - random_1()) / 1.8);
	position.x = temp * (0.5 - random_1());
	
	temp = 1e18 * (log(1 - random_1()) / 1.8);
	position.y = temp * (0.5 - random_1());

	return position;
}


Vector random_speed(Vector r_i, double m_i) {
	// math.sqrt(FORCE_GRAVITATION * (star -> mass + )) * chaque composante du vecteur v(-sin(phi) ; cos(phi))
	// où phi = atan2(star -> position.y / star -> position.x) // tan⁻¹

	Vector* p_norm = new_vec(r_i.x, r_i.y);
	double temp = sqrt(FORCE_GRAVITATION * (m_i + (1e6 * MASSE_SOLAIRE)) / norm(p_norm));
	double phi = atan2(r_i.y, r_i.x);

	Vector speed;
	speed.x = temp * (-sin(phi));
	speed.y = temp * (cos(phi));

	return speed;
}



Star* super_star(Star* list_stars, int size_list) {
	Star* super_star = malloc(sizeof(Star));

	for (int i = 0; i < size_list; i++) {
		// position
		super_star -> pos.x += list_stars[i].pos.x;
		super_star -> pos.y += list_stars[i].pos.y;

		// accélération 
		super_star -> acc.x += list_stars[i].acc.x;
		super_star -> acc.y += list_stars[i].acc.y;

		// masse 
		super_star -> mass += list_stars[i].mass;
	}

	// ne donne pas la même chose si on fait /= 2 pour chaque boucle for
	super_star -> pos.x /= size_list;
	super_star -> pos.y /= size_list;
	super_star -> acc.x /= size_list;
	super_star -> acc.y /= size_list;
	super_star -> mass /= size_list;

	return super_star;
}


Vector* resultante(Vector* list_stars, int size_list) {
	Vector* Fi = new_vec(0.0, 0.0);

	for (int i = 0; i < size_list; i++) {
		for (int j = 0; j < size_list; j++) {
			if (j != i) {
				/*
				Vector* rj_ri = sub_vec(&(list_stars[j] -> pos), &(list_stars[i] -> pos));
				int G_mi_mj = FORCE_GRAVITATION * list_stars[i] -> mass * list_stars[j] -> mass;
				Vector* temp = mul_vec(rj_ri, G_mi_mj);

				Fi = add_vec(Fi, temp)
				*/
			}
		}
	}
	
	Fi -> x /= size_list;
	Fi -> y /= size_list;

	return Fi;
}

void new_position(Star* star, Vector resultante) {
	star -> acc = *(add_vec(&(star -> acc), &resultante));
}




int random_10() {
	return ((rand() % 10) + 1);
}

double random_1() {
	return ((rand() % 10) / 10);
}





/* * * * * * * * * * * * * * * * *
* 				                 *
*          --- TESTS ---         *
*				                 *
* * * * * * * * * * * * * * * * */

void tests_star() {
	printf("TESTS STAR : \n");
	
	Vector* position = new_vec(4.0, 5.0);
	Vector* speed = new_vec(4.0, 5.0);
	Vector* acceleration = new_vec(4.0, 5.0);

	Star* s1 = new_star_vel(*position, *speed, *acceleration, MASSE_MIN, DELTA_T);
	print_star(s1);
	



	free(s1);
	free(position);
	free(speed);
	free(acceleration);


	printf("\n");
}