Skip to content
Snippets Groups Projects
Commit a726433a authored by ExtraDev's avatar ExtraDev
Browse files

refactor and calc gradient with groups

parent e8418f7b
No related branches found
No related tags found
No related merge requests found
Showing with 186 additions and 111 deletions
{
"C_Cpp.errorSquiggles": "Disabled"
}
\ No newline at end of file
......@@ -25,8 +25,12 @@ Ci-dessous un exemple du résultat attendu, à savoir, connaitre la meilleure dr
![Exemple ](./doc/screenshots/exemple.png){width=400px}
# Méthodes employée
## Solution analytique - Merci le tableur
## Solution analytique
En premier lieux, nous avons cherchons à minimiser la fonction de coût:
E(a,b) = $\sum_{j=1}^n (a * x_{j} + b - y_{i})^2$
En résolvant le système de deux équations à deux inconnues.
## Solution numérique
......
File deleted
File deleted
......@@ -2,7 +2,7 @@ CC=gcc
CFLAGS=-Wall -Wextra -std=c11 -g -fsanitize=leak -fsanitize=undefined -fsanitize=address
LDFLAGS=-lm
FOLDER = ./
FOLDER = .
SOURCES = $(wildcard $(FOLDER)/*.c)
OBJECTS = $(SOURCES:.c=.o)
......
No preview for this file type
#include "equation.h"
double get_random() {
double get_random_between_0_and_1() {
return ((double)(rand() % (RND_MAX + 1 - RND_MIN) + RND_MIN))/1; // non rabatu entre 0 et 1 pour un meilleur résultat visuel
}
......@@ -11,28 +11,17 @@ int get_random_int(int min, int max) {
void generate_points(point_t* points, int N) {
for(int i = 0; i < N; i++){
point_t pt;
pt.x = (i * GRAPH_X) / NB_POINTS; // -nan and inf, get_random() work
pt.y = EQUATION_PENTE * pt.x + EQUATION_ORDO + get_random();
pt.x = (i * GRAPH_X) / NB_POINTS; // -nan and inf, get_random_between_0_and_1() work
pt.y = EQUATION_PENTE * pt.x + EQUATION_ORDO + get_random_between_0_and_1();
// printf("points[%d] = (point_t){.x=%f, .y=%f};\n", i, pt.x, pt.y);
points[i] = pt;
}
}
void split_point_into_groups(point_t* points, point_t** groups, int n_points, int n_groups) {
int cpt = 0;
for (int i = 0; i < n_points; i++) {
if(i % n_groups-1 == 0) {
cpt++;
}
groups[cpt][i] = points[i];
}
}
void create_group(group_t *group, point_t* points, int n_points, int n_groups) {
group->n_points = n_points;
group->n_groups = n_groups;
group->n_points_in_group = (int)(n_points/n_groups);
group->points = malloc(sizeof(point_t*) * n_groups);
for (int i = 0; i < group->n_groups; i++) {
......@@ -82,16 +71,17 @@ void create_group_random(group_t *group, point_t* points, int n_points, int n_gr
// generate group
group->n_points = n_points;
group->n_groups = n_groups;
group->n_points_in_group = (int)(n_points/n_groups);
group->points = malloc(sizeof(point_t*) * n_groups);
for (int i = 0; i < group->n_groups; i++) {
group->points[i] = malloc(sizeof(point_t) * (int)(n_points/n_groups));
group->points[i] = malloc(sizeof(point_t) * group->n_points_in_group);
}
int cpt = 0;
int cpt2 = 0;
for (int i = 0; i < n_points; i++) {
if(i % (int)(n_points/n_groups) == 0) {
if(i % group->n_points_in_group == 0) {
cpt++;
cpt2 = 0;
}
......@@ -105,24 +95,27 @@ void create_group_random(group_t *group, point_t* points, int n_points, int n_gr
free(tmp);
}
point_t* group(group_t *group, int a, int b) {
int nb_points = (int)(group->n_points/group->n_groups) * 2; // 30 / 3 * 2 = 20
point_t* regroup(group_t *group, int cadran_a, int cadran_b) {
int nb_points = group->n_points_in_group * 2; // 30 / 3 * 2 = 20
point_t* result = malloc(sizeof(point_t) * nb_points);
for (int i = 0; i < nb_points/2; i++)
{
result[i] = group->points[a][i];
result[nb_points/2+i] = group->points[b][i];
result[i] = group->points[cadran_a][i];
result[nb_points/2+i] = group->points[cadran_b][i];
}
return result;
}
void print_group(group_t *group){
printf("nb points %d ", group->n_points);
printf("nb groups %d ", group->n_groups);
printf("points per group %d \n", group->n_points_in_group);
for (int i = 0; i < group->n_groups; i++)
{
for (int j = 0; j < (int)(group->n_points/group->n_groups); j++)
for (int j = 0; j < group->n_points_in_group; j++)
{
printf("[%d:%d] = %f,%f\n", i, j, group->points[i][j].x, group->points[i][j].y);
}
......@@ -149,7 +142,7 @@ double erreur_quadratique(double a, double b, point_t* points, int nb_points) {
return res;
}
vector_t descente_radian(point_t* points, int N)
vector_t descente_gradient(point_t* points, int N)
{
double A = 0;
double B = 0;
......@@ -163,7 +156,7 @@ vector_t descente_radian(point_t* points, int N)
D += points[i].y;
}
printf("A = %f, B = %f, C = %f, D = %f\n",A,B,C,D);
// printf("A = %f, B = %f, C = %f, D = %f\n",A,B,C,D);
vector_t vold = {.x=1, .y=1};
vector_t vnew = {.x=2, .y=2}; //x = a , y = b
......@@ -182,7 +175,7 @@ vector_t descente_radian(point_t* points, int N)
cpt++;
}
printf("Iterations: %d\n",cpt);
// printf("Iterations: %d\n",cpt);
return vnew;
}
......
......@@ -21,7 +21,7 @@ typedef struct _point_t {
} point_t;
typedef struct _group_t {
int n_points, n_groups;
int n_points, n_groups, n_points_in_group;
point_t **points;
} group_t;
......@@ -31,26 +31,19 @@ typedef struct _vector_t {
} vector_t;
double get_random();
double get_random_between_0_and_1();
int get_random_int(int min, int max);
void generate_points(point_t* points, int N);
void split_point_into_groups(point_t* points, point_t** groups, int n_points, int n_groups);
vector_t descente_radian(point_t* points, int N);
vector_t direction_croissance();
vector_t descente_gradient(point_t* points, int N);
double erreur_quadratique(double a, double b, point_t* points, int nb_points);
double f(vector_t x); // test
double fd(vector_t x); // test
// Gestion des groupes
void create_group(group_t *group, point_t* points, int n_points, int n_groups);
void create_group_random(group_t *group, point_t* points, int n_points, int n_groups);
point_t* group(group_t *group, int a, int b);
point_t* regroup(group_t *group, int cadran_a, int cadran_b);
void print_group(group_t *group);
void destroy_group(group_t *group);
......
......@@ -8,7 +8,7 @@
int main(int argc, char* argv[]) {
srand( time( NULL ) );
point_t* points;
point_t* nuage_points;
int nb_points = NB_POINTS;
......@@ -19,76 +19,122 @@ int main(int argc, char* argv[]) {
nb_points--;
}
points = malloc(sizeof(point_t)*nb_points);
generate_points(points, nb_points);
nuage_points = malloc(sizeof(point_t)*nb_points);
generate_points(nuage_points, nb_points);
} else {
points = malloc(sizeof(point_t)*NB_POINTS);
points[0] = (point_t){.x=0.000000, .y=0.600000};
points[1] = (point_t){.x=0.000000, .y=1.000000};
points[2] = (point_t){.x=0.000000, .y=0.600000};
points[3] = (point_t){.x=1.000000, .y=1.200000};
points[4] = (point_t){.x=1.000000, .y=1.100000};
points[5] = (point_t){.x=1.000000, .y=1.400000};
points[6] = (point_t){.x=2.000000, .y=2.000000};
points[7] = (point_t){.x=2.000000, .y=2.600000};
points[8] = (point_t){.x=2.000000, .y=2.300000};
points[9] = (point_t){.x=3.000000, .y=3.100000};
points[10] = (point_t){.x=3.000000, .y=3.800000};
points[11] = (point_t){.x=3.000000, .y=3.700000};
points[12] = (point_t){.x=4.000000, .y=4.500000};
points[13] = (point_t){.x=4.000000, .y=4.300000};
points[14] = (point_t){.x=4.000000, .y=4.700000};
points[15] = (point_t){.x=5.000000, .y=5.400000};
points[16] = (point_t){.x=5.000000, .y=5.900000};
points[17] = (point_t){.x=5.000000, .y=6.000000};
points[18] = (point_t){.x=6.000000, .y=6.200000};
points[19] = (point_t){.x=6.000000, .y=6.000000};
points[20] = (point_t){.x=6.000000, .y=7.000000};
points[21] = (point_t){.x=7.000000, .y=7.800000};
points[22] = (point_t){.x=7.000000, .y=7.500000};
points[23] = (point_t){.x=7.000000, .y=7.000000};
points[24] = (point_t){.x=8.000000, .y=8.400000};
points[25] = (point_t){.x=8.000000, .y=8.600000};
points[26] = (point_t){.x=8.000000, .y=8.000000};
points[27] = (point_t){.x=9.000000, .y=10.000000};
points[28] = (point_t){.x=9.000000, .y=9.300000};
points[29] = (point_t){.x=9.000000, .y=10.000000};
nuage_points = malloc(sizeof(point_t)*NB_POINTS);
nuage_points[0] = (point_t){.x=0.000000, .y=0.600000};
nuage_points[1] = (point_t){.x=0.000000, .y=1.000000};
nuage_points[2] = (point_t){.x=0.000000, .y=0.600000};
nuage_points[3] = (point_t){.x=1.000000, .y=1.200000};
nuage_points[4] = (point_t){.x=1.000000, .y=1.100000};
nuage_points[5] = (point_t){.x=1.000000, .y=1.400000};
nuage_points[6] = (point_t){.x=2.000000, .y=2.000000};
nuage_points[7] = (point_t){.x=2.000000, .y=2.600000};
nuage_points[8] = (point_t){.x=2.000000, .y=2.300000};
nuage_points[9] = (point_t){.x=3.000000, .y=3.100000};
nuage_points[10] = (point_t){.x=3.000000, .y=3.800000};
nuage_points[11] = (point_t){.x=3.000000, .y=3.700000};
nuage_points[12] = (point_t){.x=4.000000, .y=4.500000};
nuage_points[13] = (point_t){.x=4.000000, .y=4.300000};
nuage_points[14] = (point_t){.x=4.000000, .y=4.700000};
nuage_points[15] = (point_t){.x=5.000000, .y=5.400000};
nuage_points[16] = (point_t){.x=5.000000, .y=5.900000};
nuage_points[17] = (point_t){.x=5.000000, .y=6.000000};
nuage_points[18] = (point_t){.x=6.000000, .y=6.200000};
nuage_points[19] = (point_t){.x=6.000000, .y=6.000000};
nuage_points[20] = (point_t){.x=6.000000, .y=7.000000};
nuage_points[21] = (point_t){.x=7.000000, .y=7.800000};
nuage_points[22] = (point_t){.x=7.000000, .y=7.500000};
nuage_points[23] = (point_t){.x=7.000000, .y=7.000000};
nuage_points[24] = (point_t){.x=8.000000, .y=8.400000};
nuage_points[25] = (point_t){.x=8.000000, .y=8.600000};
nuage_points[26] = (point_t){.x=8.000000, .y=8.000000};
nuage_points[27] = (point_t){.x=9.000000, .y=10.000000};
nuage_points[28] = (point_t){.x=9.000000, .y=9.300000};
nuage_points[29] = (point_t){.x=9.000000, .y=10.000000};
}
group_t groups;
create_group_random(&groups, points, nb_points, 3);
print_group(&groups);
create_group_random(&groups, nuage_points, nb_points, 3);
point_t* groupe_0_1 = regroup(&groups, 0, 1);
point_t* groupe_0_2 = regroup(&groups, 0, 2);
point_t* groupe_1_2 = regroup(&groups, 1, 2);
// Exemple of grouping two groups
point_t* yes = group(&groups, 0, 1);
vector_t droite_nuage = descente_gradient(nuage_points, nb_points);
vector_t droite_0_1 = descente_gradient(groupe_0_1, groups.n_points_in_group);
vector_t droite_0_2 = descente_gradient(groupe_0_2, groups.n_points_in_group);
vector_t droite_1_2 = descente_gradient(groupe_1_2, groups.n_points_in_group);
for (int i = 0; i < 20; i++)
{
printf("%f, %f\n", yes[i].x, yes[i].y);
}
// Faire la comparaison des gradient
printf("Gradient nuage complet: %f;%f\n", droite_nuage.x, droite_nuage.y);
printf("Gradient ground 0-1: %f;%f\n", droite_0_1.x, droite_0_1.y);
printf("Gradient ground 0-2: %f;%f\n", droite_0_2.x, droite_0_2.y);
printf("Gradient ground 1-2: %f;%f\n", droite_1_2.x, droite_1_2.y);
// Préparation à l'export
point_t* nuage_AB = malloc(sizeof(point_t));
*nuage_AB = (point_t){droite_nuage.x, droite_nuage.y};
point_t* nuage_0_1 = malloc(sizeof(point_t));
*nuage_0_1 = (point_t){droite_0_1.x, droite_0_1.y};
point_t* nuage_0_2 = malloc(sizeof(point_t));
*nuage_0_2 = (point_t){droite_0_2.x, droite_0_2.y};
point_t* nuage_1_2 = malloc(sizeof(point_t));
*nuage_1_2 = (point_t){droite_1_2.x, droite_1_2.y};
double_vector_t *points_X = create_vector_x(nuage_points, nb_points);
double_vector_t *points_Y = create_vector_y(nuage_points, nb_points);
double_vector_t *droite_nuage_complet_A = create_vector_x(nuage_AB, 1);
double_vector_t *droite_nuage_complet_B = create_vector_y(nuage_AB, 1);
double_vector_t *droite_nuage_0_1_A = create_vector_x(nuage_0_1, 1);
double_vector_t *droite_nuage_0_1_B = create_vector_y(nuage_0_1, 1);
double_vector_t *droite_nuage_0_2_A = create_vector_x(nuage_0_2, 1);
double_vector_t *droite_nuage_0_2_B = create_vector_y(nuage_0_2, 1);
double_vector_t *droite_nuage_1_2_A = create_vector_x(nuage_1_2, 1);
double_vector_t *droite_nuage_1_2_B = create_vector_y(nuage_1_2, 1);
export_vector("../points_X.vec", points_X);
export_vector("../points_Y.vec", points_Y);
export_vector("../droite_nuage_complet_A.vec", droite_nuage_complet_A);
export_vector("../droite_nuage_complet_B.vec", droite_nuage_complet_B);
export_vector("../droite_nuage_0_1_A.vec", droite_nuage_0_1_A);
export_vector("../droite_nuage_0_1_B.vec", droite_nuage_0_1_B);
export_vector("../droite_nuage_0_2_A.vec", droite_nuage_0_2_A);
export_vector("../droite_nuage_0_2_B.vec", droite_nuage_0_2_B);
export_vector("../droite_nuage_1_2_A.vec", droite_nuage_1_2_A);
export_vector("../droite_nuage_1_2_B.vec", droite_nuage_1_2_B);
vector_t resAB = descente_radian(points, nb_points);
point_t* AB = malloc(sizeof(point_t));
*AB = (point_t){resAB.x, resAB.y};
printf("gradient(%f,%f)\n", resAB.x, resAB.y);
double_vector_t *X = create_vector_x(points, nb_points);
double_vector_t *Y = create_vector_y(points, nb_points);
double_vector_t *A = create_vector_x(AB, 1);
double_vector_t *B = create_vector_y(AB, 1);
free(nuage_points);
free(nuage_AB);
free(nuage_0_1);
free(nuage_0_2);
free(nuage_1_2);
export_vector("../X.vec", X);
export_vector("../Y.vec", Y);
export_vector("../A.vec", A);
export_vector("../B.vec", B);
free(groupe_0_1);
free(groupe_0_2);
free(groupe_1_2);
free(points);
free(AB);
destroy_vector(&points_X);
destroy_vector(&points_Y);
destroy_vector(&droite_nuage_complet_A);
destroy_vector(&droite_nuage_complet_B);
destroy_vector(&X);
destroy_vector(&Y);
destroy_vector(&A);
destroy_vector(&B);
destroy_vector(&droite_nuage_0_1_A);
destroy_vector(&droite_nuage_0_1_B);
destroy_vector(&droite_nuage_0_2_A);
destroy_vector(&droite_nuage_0_2_B);
destroy_vector(&droite_nuage_1_2_A);
destroy_vector(&droite_nuage_1_2_B);
destroy_group(&groups);
}
\ No newline at end of file
......@@ -3,19 +3,18 @@ from numpy.lib.npyio import loadtxt
from load_vec import load_vector
import numpy as np
X_nuage_point = load_vector("../X.vec")
Y_nuage_point = load_vector("../Y.vec")
X_nuage_point = load_vector("../points_X.vec")
Y_nuage_point = load_vector("../points_Y.vec")
A = load_vector("../A.vec") #
B = load_vector("../B.vec") #
droite_nuage_complet_A = load_vector("../droite_nuage_complet_A.vec")
droite_nuage_complet_B = load_vector("../droite_nuage_complet_B.vec")
# Nuage de points
plt.scatter(X_nuage_point, Y_nuage_point, marker='x', label="Points")
plt.scatter(X_nuage_point, Y_nuage_point, marker='.', label="Points")
# Meilleure droite
x = np.array(range(int(max(X_nuage_point))+1))
y = x * A + B
y = x * droite_nuage_complet_A + droite_nuage_complet_B
plt.plot(x, y, label="Meilleure droite", color="red")
......
from matplotlib import pyplot as plt
from numpy.lib.npyio import loadtxt
from load_vec import load_vector
import numpy as np
fig, (ax1, ax2, ax3) = plt.subplots(3)
fig.suptitle('Vertically stacked subplots')
X_nuage_point = load_vector("../points_X.vec")
Y_nuage_point = load_vector("../points_Y.vec")
droite_nuage_0_1_A = load_vector("../droite_nuage_0_1_A.vec")
droite_nuage_0_1_B = load_vector("../droite_nuage_0_1_B.vec")
droite_nuage_0_2_A = load_vector("../droite_nuage_0_2_A.vec")
droite_nuage_0_2_B = load_vector("../droite_nuage_0_2_B.vec")
droite_nuage_1_2_A = load_vector("../droite_nuage_1_2_A.vec")
droite_nuage_1_2_B = load_vector("../droite_nuage_1_2_B.vec")
x = np.array(range(int(max(X_nuage_point))+1))
y = x * droite_nuage_0_1_A + droite_nuage_0_1_B
ax1.scatter(X_nuage_point, Y_nuage_point, marker='.', label="Points")
ax1.plot(x, y, label="Meilleure droite", color="red")
x = np.array(range(int(max(X_nuage_point))+1))
y = x * droite_nuage_0_2_A + droite_nuage_0_2_B
ax2.scatter(X_nuage_point, Y_nuage_point, marker='.', label="Points")
ax2.plot(x, y, label="Meilleure droite", color="red")
x = np.array(range(int(max(X_nuage_point))+1))
y = x * droite_nuage_1_2_A + droite_nuage_1_2_B
ax3.scatter(X_nuage_point, Y_nuage_point, marker='.', label="Points")
ax3.plot(x, y, label="Meilleure droite", color="red")
plt.show()
File deleted
File added
File added
File added
File added
File added
File added
File added
File added
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment