ann *ann_leer_red(FILE *archivo_red){
ann *red = NULL;
int *capas = NULL;
int n_capas, r, total;
float **pesos;
int i,j,k;
/* Lee la cantidad de capas */
fread(&n_capas, sizeof(int), 1, archivo_red);
/* Vector para crear la red */
capas = (int *) malloc(sizeof(int) * n_capas);
if(capas == NULL) error_mem();
fread(capas, sizeof(int), n_capas, archivo_red);
/* Crea la red con el vector*/
red = ann_crear_red(capas, n_capas);
/* Inicializa los pesos con el archivo */
for(i = 1; i < n_capas; i++){
pesos = red->capas[i-1].pesos;
for(j = 0; j < capas[i]; j++)
fread(pesos[j], sizeof(float), capas[i-1], archivo_red);
fread(red->capas[i-1].bias, sizeof(float), capas[i], archivo_red);
}
return red;
}
ann *ann_crear_red(int *capas, int n){
int i,j;
ann *red = NULL;
float **pesos_i = NULL;
red = (ann *) malloc(sizeof(ann));
if(red == NULL) error_mem();
red->n_capas = n;
red->entrada = (capa_entrada *) malloc(sizeof(capa_entrada));
if(red->entrada == NULL) error_mem();
red->entrada->n_nodos = capas[0];
red->entrada->x0 = 1.0;
/*red->entrada->salidas = (float *) malloc(sizeof(float) * capas[0]);
if(red->entrada->salidas == NULL) error_mem();*/
red->capas = (capa_oculta *) malloc(sizeof(capa_oculta) * n-1);
if(red->capas == NULL) error_mem();
for(i = 1; i < n; i++){
red->capas[i-1].n_nodos = capas[i];
red->capas[i-1].salidas = (float *) malloc(sizeof(float) * capas[i]);
if(red->capas[i-1].salidas == NULL) error_mem();
red->capas[i-1].bias = (float *) malloc(sizeof(float) * capas[i]);
if(red->capas[i-1].bias == NULL) error_mem();
pesos_i = (float **) malloc(sizeof(float *) * capas[i]);
if(pesos_i == NULL) error_mem();
for(j = 0; j < capas[i]; j++){
pesos_i[j] = (float *) malloc(sizeof(float) * capas[i-1]);
if(pesos_i[j] == NULL) error_mem();
}
red->capas[i-1].pesos = pesos_i;
}
return red;
}
void process_top_path(char* pathname)
{
bool free_path = false;
//On ajoute un / à la fin du pathname si il n'en contient pas déjà un
if(pathname[strlen(pathname)-1] == '/')
path_process = pathname;
else {
free_path = true;
path_process = malloc(strlen(pathname)+1);
if(path_process == NULL) {
error_mem();
exit(EXIT_FAILURE);
}
memcpy(path_process, pathname, strlen(pathname));
path_process[strlen(pathname)] = '/';
}
/*On se place dans le dossier de départ pour que les commandes suivantes comprennent
les chemins relatifs */
if(chdir(path_process) != -1) { //Si l'ouverture s'est bien passé on execute process_path
struct stat stat_file;
if(lstat(pathname, &stat_file) != -1) {
if(current_level >= mindepth)
apply_predicates(pathname, &stat_file);
if(!S_ISLNK(stat_file.st_mode))
process_path(path_process);
}
}
else {
if(errno == EACCES) { //Si l'ouveture ne s'est pas bien passé et que c'est un problème de permissions
struct stat stat_file;
if(lstat(path_process, &stat_file) != -1 && current_level >= mindepth) {
apply_predicates(pathname, &stat_file);
}
}
fprintf(stderr,"%s: \"%s\": %s\n", program_name, pathname, strerror_l(errno, locale));
}
if(free_path)
free(path_process);
}
void process_path(char* pathname)
{
DIR *dir = opendir(pathname);
struct dirent *file;
struct stat stat_file;
char** files_sorted = NULL;
stop_at_current_level = maxdepth >= 0 && current_level >= maxdepth;
if(sort == false) {
while((file = readdir(dir))) {
// On ne prends pas en comptes les liens '.' et '..'
if(strcmp(file->d_name, ".") != 0 && strcmp(file->d_name, "..") != 0) {
char* name = file->d_name;
int length = (strlen(name)+strlen(pathname)+2);
char* path = malloc(length);
if ( path == NULL ) {
closedir(dir);
error_mem();
exit(EXIT_FAILURE);
}
//On crée une chaine fusionnant le chemin et le fichier qu'on est en train de lire
memcpy(path, pathname, strlen(pathname));
memcpy(path+strlen(pathname), name, strlen(name));
path[length-2] = '\0';
path[length-1] = '\0';
if(lstat(path, &stat_file) != -1) {
if(current_level >= mindepth)
apply_predicates(path, &stat_file);
//Si le fichier est un dossier on lance process_dir
if(!stop_at_current_level && S_ISDIR(stat_file.st_mode) && !S_ISLNK(stat_file.st_mode)) {
path[length-2] = '/';
path[length-1] = '\0';
process_dir(path);
}
}
free(path);
}
}
}
else {
int i = 0;
while((file = readdir(dir))) {
if(strcmp(file->d_name, ".") != 0 && strcmp(file->d_name, "..") != 0) {
if(files_sorted == NULL)
files_sorted = malloc((1000)*sizeof(char*));
else if(i > 99) {
char **files_sorted_tmp = realloc(files_sorted, (i+1)*sizeof(char*));
if(files_sorted_tmp == NULL || files_sorted != files_sorted_tmp) {
closedir(dir);
error_mem();
free(files_sorted);
exit(EXIT_FAILURE);
}
files_sorted = files_sorted_tmp;
}
if ( files_sorted == NULL ) {
closedir(dir);
error_mem();
exit(EXIT_FAILURE);
}
char* name = file->d_name;
int length = (strlen(name)+strlen(pathname)+2);
files_sorted[i] = malloc(length*sizeof(char));
if ( files_sorted[i] == NULL ) {
errno = ENOMEM;
fprintf(stderr,"%s \n", strerror_l(errno, locale));
for(int j=0; j<i; j++)
free(files_sorted[j]);
free(files_sorted);
exit(EXIT_FAILURE);
}
files_sorted[i][0] = '\0';
strcat(files_sorted[i], pathname);
strcat(files_sorted[i], name);
files_sorted[i][length-2] = '\0';
files_sorted[i][length-1] = '\0';
i++;
}
}
//On trie les chemins
if(files_sorted != NULL) {
qsort(files_sorted, i, sizeof(char*), compare_pathname);
//On parcourt les chemins
for(int j=0; j<i; j++) {
if(lstat(files_sorted[j], &stat_file) != -1) {
if(current_level >= mindepth)
apply_predicates(files_sorted[j], &stat_file);
//Si le fichier est un dossier on lance process_dir
if(!stop_at_current_level && S_ISDIR(stat_file.st_mode) && !S_ISLNK(stat_file.st_mode)) {
int length = strlen(files_sorted[j]);
files_sorted[j][length] = '/';
files_sorted[j][length+1] = '\0';
process_dir(files_sorted[j]);
}
}
}
//On libere la memoire des chemins
for(int j=0; j<i; j++)
free(files_sorted[j]);
free(files_sorted);
}
}
closedir(dir);
}
