Skip to content
Snippets Groups Projects
Commit 9aed84e8 authored by simon.cirilli's avatar simon.cirilli
Browse files

Fonctions analytique et numérique finie sauf si erreurs sinon good

parent fafa4571
No related branches found
No related tags found
No related merge requests found
...@@ -7,7 +7,7 @@ LIBS=-lcunit -lm -lxml2 ...@@ -7,7 +7,7 @@ LIBS=-lcunit -lm -lxml2
all: prog all: prog
prog:src/main.o src/regressionLin.o prog:src/main.o src/regressionLin.o src/vector.o
$(CC) $^ -o $@ $(LIBS) $(SANITIZERS) $(OPTIM_OPTS) $(CC) $^ -o $@ $(LIBS) $(SANITIZERS) $(OPTIM_OPTS)
%.o : %.c %.o : %.c
......
No preview for this file type
...@@ -8,5 +8,43 @@ ...@@ -8,5 +8,43 @@
int main() { int main() {
point pt0;
pt0.x=0;
pt0.y=0;
point pt1;
pt1.x=1;
pt1.y=1;
point pt2;
pt2.x=2;
pt2.y=2;
point pt3;
pt3.x=3;
pt3.y=3;
point pt4;
pt4.x=4;
pt4.y=4;
vector v;
vector_init(&v);
vector_push(&v,pt0);
vector_push(&v,pt1);
vector_push(&v,pt2);
vector_push(&v,pt3);
vector_push(&v,pt4);
point p = findBestDroite(v);
printf("Sol Analytique : %f %f\n",p.x,p.y);
point drt;
drt.x=1;
drt.y=0;
p = descenteGradient(0.00001,drt,v);
printf("Sol Numérique : %f %f\n",p.x,p.y);
vector_free(&v);
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
No preview for this file type
#include "regressionLin.h" #include "regressionLin.h"
droite findBestDroite(point* pts){ point findBestDroite(vector pts){
// dans le cas que l'on a vu en exercice on peut directement dire : // dans le cas que l'on a vu en exercice on peut directement dire :
// car c'est la même fonction de base // car c'est la même fonction de base
double gA=0; // somme des xi ^2
double gB=0; // somme des xi
double gC=0; // sommes des xi*yi
double gD=0; // somme des yi
double gN=pts.length; // nombre de points
for(int i = 0; i < pts.length; i++){
gA += pts.content[i].x * pts.content[i].x;
gB += pts.content[i].x;
gC += pts.content[i].x * pts.content[i].y;
gD += pts.content[i].y;
}
double gA=1; // somme des xi ^2
double gB=1; // somme des xi
double gC=1; // sommes des xi*yi
double gD=1; // somme des yi
double gN=2; // nombre de points
double numerateur=gC * gN - gB * gD; double numerateur=gC * gN - gB * gD;
double denominateur=gA * gN - gB * gB; // pas possible si = 0 double denominateur=gA * gN - gB * gB; // pas possible si = 0
double a = numerateur / denominateur; double a = numerateur / denominateur;
double b = ( gC - a * gA ) / gB; double b = ( gC - a * gA ) / gB;
droite d; point d;
d.a=a; d.x=a;
d.b=b; d.y=b;
return d; return d;
} }
point minmethode1(point depart, point arrivee, droite fonction){
point descenteGradient(double precision, point drt, vector pts){
point pt; point pt;
return pt; pt.x = drt.x;
pt.y = drt.y;
double gradientx = 0;
double gradienty = 0;
double oldptx = 0;
double oldpty = 0;
double testSortie;
while(1){
gradientx = 0;
gradienty = 0;
testSortie = 0;
for(int i = 0; i < pts.length; i++){
gradientx += ((pts.content[i].x * pts.content[i].x) * drt.x) + (drt.y * pts.content[i].x) - (pts.content[i].x * pts.content[i].y);
gradienty += (drt.x * pts.content[i].x) - pts.content[i].y;
} }
gradientx = gradientx*2;
point solvSystem(droite dim1, droite dim2){ gradienty += drt.y * pts.length;
point pt; gradienty = gradienty*2;
return pt;
double lambda = 0.1;
//drt.x est a et drt.b est b
oldptx = pt.x;
oldpty = pt.y;
pt.x = drt.x - lambda *(gradientx);
pt.y = drt.y - lambda *(gradienty);
testSortie = sqrt(pow(pt.x - oldptx,2) + pow(pt.y - oldpty,2));
if(testSortie < precision){
break;
}
} }
point descenteGradient(int precision, droite drt){
point pt;
return pt; return pt;
} }
...@@ -7,29 +7,15 @@ ...@@ -7,29 +7,15 @@
#include <string.h> #include <string.h>
#include <math.h> #include <math.h>
typedef struct _point { #include "vector.h"
double x;
double y;
} point;
typedef struct _droite {
double a;
double b;
} droite;
// Analytique // Analytique
droite findBestDroite(point* pts); point findBestDroite(vector pts);
// vérifier que ce que l'on trouve soit correct à l'exercice (on a déjà fait dans un exo) // vérifier que ce que l'on trouve soit correct à l'exercice (on a déjà fait dans un exo)
// on peut donc reprendre simplement A=.. et B=.. si la fonction de base ne change pas // on peut donc reprendre simplement A=.. et B=.. si la fonction de base ne change pas
// sinon utilise solvSystem // sinon utilise solvSystem
point minmethode1(point depart, point arrivee, droite fonction);
// on doit faire ceci uniquement si la fonction de base à minimisé n'est plus la somme de a*x+b-y le tout au carré
point solvSystem(droite dim1, droite dim2);//différentes méthodes vues en classe donc minmethode1 etc.
// Numérique // Numérique
point descenteGradient(int precision, droite drt); point descenteGradient(double precision, point drt, vector pts);
#endif #endif
No preview for this file type
#include "vector.h"
void vectorPrint(vector v){
for(int i=0;i<v.length;i++){
printf("%f %f",v.content[i].x,v.content[i].y);
}
printf("\n");
}
void printError(int index){
const char* error_code_names[] = {"ok", "out_of_bounds", "memory_error", "unitialized"};
printf("%s\n", error_code_names[index]);
}
error_code vector_init(vector* v){
error_code result = ok;
v->capacity = VECTOR_INIT_CAPACITY;
v->length = 0;
v->content = malloc(sizeof(type)*VECTOR_INIT_CAPACITY);
if (v->content == NULL)
{
result = uninitialized;
}
return result;
}
error_code vector_length(vector *v, int *length){
error_code result = ok;
if (length != NULL)
{
*length = v->length;
}else{
result = uninitialized;
}
return result;
}
error_code vector_push(vector *v, type element){
error_code result = ok;
if (v->length == v->capacity)
{
v->capacity = v->capacity * 2;
v->content = realloc(v->content, sizeof(type) * v->capacity);
}
v->content[v->length] = element;
v->length++;
return result;
}
error_code vector_pop(vector *v, type *element){
error_code result = ok;
*element = v->content[v->length-1];
point pt;
pt.x=0;
pt.y=0;
v->content[v->length-1] = pt;
v->length--;
if (v->length < v->capacity/4)
{
v->capacity = v->capacity / 2;
v->content = realloc(v->content, sizeof(type) * v->capacity);
}
return result;
}
error_code vector_set(vector *v, int index, type element){
error_code result = ok;
if (index < v->length && index >= 0)
{
v->content[index] = element;
} else {
result = out_of_bounds;
}
return result;
}
error_code vector_get(vector *v, int index, type *element){
error_code result = ok;
if (index < v->length && index >= 0)
{
*element = v->content[index];
} else {
result = out_of_bounds;
}
return result;
}
error_code vector_remove(vector *v, int index){
error_code result = ok;
if (index < v->length && index >= 0)
{
for (int i = index; i < v->length; i++)
{
v->content[i] = v->content[i+1];
}
v->length--;
if (v->length < v->capacity/4){
v->capacity = v->capacity / 2;
v->content = realloc(v->content, sizeof(type) * v->capacity);
}
} else {
result = out_of_bounds;
}
return result;
}
error_code vector_insert(vector *v, type element, int index){
error_code result = ok;
if (index < v->length && index >= 0){
if (v->length == v->capacity){
v->capacity = v->capacity * 2;
v->content = realloc(v->content, sizeof(type) * v->capacity);
}
for (int i = v->length-1; i >= index; i--){
v->content[i+1] = v->content[i];
}
v->content[index] = element;
v->length++;
}else{
result = out_of_bounds;
}
return result;
}
error_code vector_free(vector *v){
error_code result = ok;
if (v->content != NULL)
{
v->capacity = -1;
v->length = -1;
free(v->content);
}
return result;
}
error_code vector_empty(vector *v){
error_code error =uninitialized;
if(v->content!=NULL){
v->length=0;
error = ok;
}
return error;
}
/*
Auteur : Simon Cirilli
Projet : Outil de gestion de vecteurs
Hesge 2019
*/
#ifndef VECTOR_H
#define VECTOR_H
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>
#define VECTOR_INIT_CAPACITY 4
typedef struct _point {
double x;
double y;
} point;
typedef point type;
typedef struct _vector {
type *content; // actual content of the vector
int capacity; // capacity allocated
int length; // actual length
} vector;
typedef enum error_code {
ok, out_of_bounds, memory_error, uninitialized
} error_code;
void printError(int index);
void vectorPrint(vector v);
error_code vector_init(vector *v);
error_code vector_length(vector *v, int *length);
error_code vector_push(vector *v, type element);
error_code vector_pop(vector *v, type *element);
error_code vector_set(vector *v, int index, type element);
error_code vector_get(vector *v, int index, type *element);
error_code vector_remove(vector *v, int index);
error_code vector_insert(vector *v, type element, int index);
error_code vector_empty(vector *v);
error_code vector_free(vector *v);
error_code vector_map(vector *v, type (*f)(type), vector *rhs);
error_code vector_filter(vector *v, bool (*f)(type), vector *rhs);
#endif
File added
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment