opti.c

#include "opti.h"
int LINE_POINTS = 1000000;
int CLOUD_POINTS = 1000;
double X_VALUE = 0.000001;
double RANDOMNESS = 0.01;


// y(x)=ax+b
Point* line(double a, double b){
    Point * points = (Point*)malloc(sizeof(Point)*LINE_POINTS);
    double x = 0.0;
    for(int i=0;i<LINE_POINTS;i++){
        Point d;
        d.x = x;
        d.y = (a*x)+b;
        points[i]=d;
        //printf("%lf, %lf", d.x, d.y);
        x+=X_VALUE;
    }
    return points;
}

double popow(double v, double w){
    double u=v;
    for(int i=1;i<w;i++){
        v*=u;
    }
    return v;
}

double double_random(double min, double max) 
{
    double my_random;
    my_random = (double)rand()/RAND_MAX*(max-min)+min;
    //printf ( "%f\n", my_random);
    
    return my_random;
}

// version 1 du nuage, se doit d'appeler line indirectement
Point* cloud1(Point* a_line){
    Point * my_cloud = (Point*)malloc(sizeof(Point)*CLOUD_POINTS);
    for(int i=0;i<CLOUD_POINTS;i++){
        Point chosen_point = a_line[rand()%LINE_POINTS-1];
        double new_y = double_random(chosen_point.y-RANDOMNESS, chosen_point.y+RANDOMNESS);
        my_cloud[i].x=chosen_point.x;
        my_cloud[i].y=new_y;
        printf("\nx = %f | y = %f\n", my_cloud[i].x,my_cloud[i].y);
    }
    return my_cloud;
}

// version 2 du nuage, peut être généré grâce aux a et b d'une droite
// génère aléatoirement des points sur l'axe des x (qui ne sont donc pas espacés uniformément)
Point* cloud2(double a, double b){
    Point * my_cloud = (Point*)malloc(sizeof(Point)*CLOUD_POINTS);
    for(int i=0;i<CLOUD_POINTS;i++){
        Point chosen_point;
        chosen_point.x = double_random(0,1);
        for(int j=0;j<CLOUD_POINTS-1;j++){
            while(chosen_point.x==my_cloud[j].x){
                chosen_point.x = double_random(0,1);
            }
        }
        double rj = double_random(-RANDOMNESS, RANDOMNESS);
        chosen_point.y = (a*chosen_point.x)+b+rj;
        my_cloud[i].x=chosen_point.x;
        my_cloud[i].y=chosen_point.y;
        printf("\nx = %f | y = %f\n", my_cloud[i].x,my_cloud[i].y);
    }
    return my_cloud;
}

// version 3 du nuage, plus simple, x espacés uniformément
Point* cloud3(double a, double b){
    Point * my_cloud = (Point*)malloc(sizeof(Point)*CLOUD_POINTS);
    for(int i=0;i<CLOUD_POINTS;i++){
        Point chosen_point;
        chosen_point.x = double_random(0,1);
        for(int j=0;j<CLOUD_POINTS-1;j++){
            while(chosen_point.x==my_cloud[j].x){
                chosen_point.x = double_random(0,1);
            }
        }
        double rj = double_random(-RANDOMNESS, RANDOMNESS);
        chosen_point.y = (a*chosen_point.x)+b+rj;
        my_cloud[i].x=chosen_point.x;
        my_cloud[i].y=chosen_point.y;
        printf("\nx = %f | y = %f\n", my_cloud[i].x,my_cloud[i].y);
    }
    return my_cloud;
}

double* average(Point* my_cloud, int cloud_size){
    double* avg = (double*)malloc(sizeof(double)*4);
    double x_avg, y_avg, x2_avg, xy_avg;
    for(int i=0; i<cloud_size-1;i++){
        x_avg+=my_cloud[i].x;
        y_avg+=my_cloud[i].y;
        x2_avg+=popow((my_cloud[i].x),2);
        xy_avg+=((my_cloud[i].x)*(my_cloud[i].y));
    }
    x_avg/=cloud_size; y_avg/=cloud_size; x2_avg/=cloud_size; xy_avg/=cloud_size;
    avg[0]=x_avg; avg[1]=y_avg; avg[2]=x2_avg; avg[3]=xy_avg;
    printf("x=%f - y=%f - x2=%f - xy=%f", avg[0],avg[1],avg[2],avg[3]);
    return avg;
}

double* a_and_b(double* my_average){
    double* a_n_b = (double*)malloc(sizeof(double)*2);
    double x_avg = my_average[0];
    double y_avg = my_average[1];
    double x2_avg = my_average[2];
    double xy_avg = my_average[3];
    double a = (xy_avg-(x_avg*y_avg))/(x2_avg-popow(x_avg,2));
    double b = y_avg-(a*x_avg);
    a_n_b[0]=a;
    a_n_b[1]=b;
    return a_n_b;
}

double cost(){
    return 0.0;
}

int main (void){
    srand ( time ( NULL));
    //Point* first_line = line(7.0, 5.5);
    Point* fluffy = cloud2(7.0, 5.5);
    average(fluffy, CLOUD_POINTS);
    printf("\ndone\n");
    return 0;
}