update: [tensor] add transpose optimized function and tests

tranfert learning find quickly a path (less crash) but from scratch learning find optimal path (shorter and faster)

deepQlearn_0/src/deepQlearning/learn_to_drive.c

@@ -74,13 +74,14 @@ struct networks_qlearning * create_network_qlearning(
   setup_networks_alloutputs_config_TYPE_FLOAT(&(qnets->best_net), config, false, minR, maxR, randomRange);  
   copy_weight_in_networks_from_main_to_best(qnets);
 
-  setup_all_layers_functions_TYPE_FLOAT(qnets->main_net, tensorContractnProdThread_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
+  setup_all_layers_functions_TYPE_FLOAT(qnets->main_net, tensorContractnProdThreadOpt0_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
+  //setup_all_layers_functions_TYPE_FLOAT(qnets->main_net, tensorContractnProdThread_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
   //setup_all_layers_functions_TYPE_FLOAT(qnets->main_net, tensorContractnProdTHR_TYPE_FLOAT, tensorProdTHR_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
   setup_all_layers_params_TYPE_FLOAT(qnets->main_net, nb_prod_thread, nb_calc_thread, learning_rate);
-  setup_all_layers_functions_TYPE_FLOAT(qnets->target_net, tensorContractnProdThread_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
+  setup_all_layers_functions_TYPE_FLOAT(qnets->target_net, tensorContractnProdThreadOpt0_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
   //setup_all_layers_functions_TYPE_FLOAT(qnets->target_net, tensorContractnProdTHR_TYPE_FLOAT, tensorProdTHR_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
   setup_all_layers_params_TYPE_FLOAT(qnets->target_net, nb_prod_thread, nb_calc_thread, learning_rate);
-  setup_all_layers_functions_TYPE_FLOAT(qnets->best_net, tensorContractnProdThread_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
+  setup_all_layers_functions_TYPE_FLOAT(qnets->best_net, tensorContractnProdThreadOpt0_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
   //setup_all_layers_functions_TYPE_FLOAT(qnets->best_net, tensorContractnProdTHR_TYPE_FLOAT, tensorProdTHR_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
   setup_all_layers_params_TYPE_FLOAT(qnets->best_net, nb_prod_thread, nb_calc_thread, learning_rate);
 
@@ -276,6 +277,7 @@ void free_RL_agent(struct RL_agent *rlAgent){
 }
 
 #define ACCEPTABLE_REWARD 1000
+#define VERY_GOOD_REWARD 10000
 
 #define UPDATE_PARAMS 1
 #define UPDATE_EXPLOR_FAC 1
@@ -322,6 +324,7 @@ void train_qlearning(struct RL_agent * rlAgent,
 #if UPDATE_PARAMS
 	if((car_status->cumulative_reward > ACCEPTABLE_REWARD) || (rlAgent->status->nb_episodes % 100 == 0) ){ 
   	float new_value = ( (net_main->learning_rate < qlParams->minimum_threshold_learning_rate /*0.0001*/) ? net_main->learning_rate :(net_main->learning_rate ) * qlParams->factor_update_learning_rate   /*0.995*/ );
+	  if(car_status->cumulative_reward > VERY_GOOD_REWARD) new_value = (net_main->learning_rate ) * qlParams->factor_update_learning_rate ;
     UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, net_main, learning_rate, new_value);
     qlParams->learning_rate = new_value;
 #if UPDATE_EXPLOR_FAC
@@ -464,8 +467,11 @@ if(/*(qlStatus->nb_episodes %125 == 0)  &&*/  pprint->printed){
 char *fileNameDateScore(char * pre, char* post,size_t score){
   char *filename=malloc(256);
   time_t t = time(NULL);
-  struct tm tm = *localtime(&t);
-  sprintf(filename,"%s%d%02d%02d_%02dh%02dm%02ds_%ld%s",pre, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,score,post);
+  ///struct tm tm = *localtime(&t);
+  //sprintf(filename,"%s%d%02d%02d_%02dh%02dm%02ds_%ld%s",pre, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,score,post);
+  ///sprintf(filename,"%s_%d%02d%02d%02d%02d%02d_%ld%s",pre, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,score,post);
+  //char sep='_';
+  sprintf(filename,"%s%c%ld%c%ld%c%s",pre, sep, t, sep,score,sep,post);
 
   return filename;
 }

deepQlearn_0/src/deepQlearning/learn_to_drive.h

@@ -38,6 +38,7 @@
 //#define main_symlink ".ff_main_.symlink"
 
 extern char *action_name[8];
+extern char sep;
 
 struct qlearning_params {
   float gamma;

dimension_t/Makefile

@@ -3,10 +3,11 @@ CC=gcc
 ROOTPROJECTDIR:=$(realpath ..)
 TOOLDIR=$(ROOTPROJECTDIR)/ytools_t
 PERMDIR=$(ROOTPROJECTDIR)/ypermutation_t
+LISTDIR=$(ROOTPROJECTDIR)/list_t
 
 INCLUDE_PERMDIR=$(PERMDIR)/src 
 INCLUDE_TOOLDIR=$(TOOLDIR)/include
-CFLAGS=-I$(INCLUDE_TOOLDIR) -I$(INCLUDE_PERMDIR) -I./src 
+CFLAGS=-I$(INCLUDE_TOOLDIR) -I$(INCLUDE_PERMDIR) -I./src -I$(LISTDIR)/src
 
 #SRC_DIR=$(ROOT_DIR)/src
 #SRC=$(wildcard */*/*.c) 
@@ -26,20 +27,22 @@ PERMSRC_O=$(PERMDIR)/src/permutation_t/permutation_t.o
 #SRC=$(wildcard **/**/*.c) 
 #OBJ=$(SRC:.c=.o) #$(TOOLSRC_O) 
 
+OBJ=$(DIMSRC_O) $(PERMSRC_O) 
+
 TOPTARGETS := all clean
-DEP=$(PERMDIR)
+DEP=$(PERMDIR) $(LISTDIR)
 
 $(TOPTARGETS): $(DEP)
 
 all: $(DIMSRC_O)
 
 
-$(DIMSRC_O) : $(DIMSRC) $(PERMSRC_O)
-	$(CC) -o $@ -c $< $(CFLAGS)
-
 $(DEP):
 	$(MAKE) -C $@ $(MAKECMDGOALS)
 
+$(DIMSRC_O) : $(DIMSRC) $(PERMSRC_O)
+	$(CC) -o $@ -c $< $(CFLAGS)
+
 #$(TOOLSRC_O): $(TOOLSRC) 
 #	$(CC) -o $@ -c $< $(CFLAGS)
 

dimension_t/src/dimension_t/dimension_t.c

@@ -209,7 +209,7 @@ void min_dimension(dimension **d, dimension *d0, dimension *d1) {
 
 void printDebug_dimension(dimension *d,char *msg){
 
-  printf("(%s)->size = %ld | (%s)->rank = %ld \n[",msg,d->size,msg,d->rank);
+  printf("<%p>(%s)->size = %ld | (%s)->rank = %ld \n[",d,msg,d->size,msg,d->rank);
   for(size_t i=0; i<d->size; ++i)
     printf(" %ld,", d->perm[i]);
   printf("] \n");
@@ -451,3 +451,11 @@ void free_list_perm_in_dim(list_perm_in_dim *l_p){
   }
 }
 
+GEN_LIST_ALL(dimension)
+
+GEN_LIST_ALL(ptr_DIMENSION)
+GEN_FUNC_PTR_LIST_FREE(ptr_DIMENSION){
+  dimension *pdim=(dimension*)arg;
+  free_dimension(pdim);
+  //free(pdim);
+}

dimension_t/src/dimension_t/dimension_t.h

@@ -2,6 +2,7 @@
 #define __DIMENSION_T__H__
 
 #include "permutation_t/permutation_t.h"
+#include "list_t/list_t.h"
 
 extern bool endian;
 
@@ -74,5 +75,11 @@ dimension * create_binary_dim(size_t dimension_size);
 
 void free_list_perm_in_dim(list_perm_in_dim *l_p);
 
+GENERATE_LIST_ALL(dimension)
+typedef dimension * ptr_DIMENSION;
+
+GENERATE_LIST_ALL(ptr_DIMENSION)
+GEN_HEAD_PTR_LIST(ptr_DIMENSION)
+
 #endif /* __DIMENSION_T__H__ */
 //int compare_dimension(dimension *d1, dimension *d2);

neuron_t/Makefile

@@ -9,12 +9,13 @@ YTESTDIR=$(ROOTPROJECTDIR)/ytest_t
 YPERMDIR=$(ROOTPROJECTDIR)/ypermutation_t
 
 TENSDIR=$(ROOTPROJECTDIR)/tensor_t
+LISTDIR=$(ROOTPROJECTDIR)/list_t
 
 NEURODIR=$(ROOT_DIR)
 DIMDIR=$(ROOTPROJECTDIR)/dimension_t
 
 #CFLAGS=-I$(INCLUDE_DIR) -I$(YPERMDIR)/src -I$(YTESTDIR)/include_ytest/include -I$(DIMDIR)/src -I$(TENSDIR)/src #"-D DEBUG=1"
-INCLUDE=-I$(NEURODIR)/src -I$(YPERMDIR)/src -I$(DIMDIR)/src -I$(TENSDIR)/src #"-D DEBUG=1"
+INCLUDE=-I$(NEURODIR)/src -I$(YPERMDIR)/src -I$(DIMDIR)/src -I$(TENSDIR)/src -I$(LISTDIR)/src #"-D DEBUG=1"
 #LDFLAGS=-L$(YTESTDIR) -lytest -lOpenCL -lm -lpthread
 #CFLAGS= -Wall -Werror -fpic $(INCLUDE)
 CFLAGS= -Wall -Werror -fpic $(INCLUDE)

neuron_t/src/neuron_t/neuron_t.c

@@ -39,9 +39,103 @@ void free_config_layers(config_layers *pconf){
   free(pconf);
 } 
 
+long int cmp_config_layers(config_layers *c1, config_layers *c2){
+  long int diff_nb=c1->nb_layers - c2->nb_layers;
+  if(diff_nb) return diff_nb;
+
+  for(long int i=0; i<c1->nb_layers; ++i){
+    long int diff_sz_layers = c1->sz_layers[i] - c2->sz_layers[i];
+    if(diff_sz_layers) return diff_sz_layers;
+    for(long int j=0; j<c1->sz_layers[i]; ++j){
+      long int diff_dim = c1->array_dim_in_layers[i][j] -  c2->array_dim_in_layers[i][j]; 
+      if(diff_dim) return diff_dim;
+    }
+  }
+  return 0;
+}
+
+config_layers * create_config_layers_from_m_list_ptr_DIMENSION(struct main_list_ptr_DIMENSION *m_l_dim){
+  config_layers * pconf=malloc(sizeof(struct config_layers));
+  pconf->nb_layers=m_l_dim->size;
+  //printf("debug: pconf->nb_layers=%ld\n",pconf->nb_layers);
+  pconf->sz_layers=malloc(pconf->nb_layers * sizeof(size_t));
+  pconf->array_dim_in_layers=malloc((pconf->nb_layers)*sizeof(size_t*));
+  for(struct list_ptr_DIMENSION *local_l_dim=m_l_dim->begin_list; local_l_dim; local_l_dim=local_l_dim->next){
+    size_t i = local_l_dim->index;
+    pconf->sz_layers[i]=local_l_dim->value->size;
+  //printf("debug: pconf->sz_layers[%ld]=%ld\n",i,pconf->sz_layers[i]);
+    pconf->array_dim_in_layers[i]=malloc((pconf->sz_layers[i])*sizeof(size_t));
+    for(size_t j=0; j< pconf->sz_layers[i];++j){
+      pconf->array_dim_in_layers[i][j] = local_l_dim->value->perm[j];
+  //printf("debug: pconf->array_dim_in_layers[%ld][%ld]=%ld\n",i,j,pconf->array_dim_in_layers[i][j]);
+    
+    }
+  }
+  return pconf;
+}
+
+
+config_layers * create_config_layers_from_m_list_dimension(struct main_list_dimension * m_l_dim){
+  config_layers * pconf=malloc(sizeof(struct config_layers));
+  pconf->nb_layers=m_l_dim->size;
+  //printf("debug: pconf->nb_layers=%ld\n",pconf->nb_layers);
+  pconf->sz_layers=malloc(pconf->nb_layers * sizeof(size_t));
+  pconf->array_dim_in_layers=malloc((pconf->nb_layers)*sizeof(size_t*));
+  for(struct list_dimension *local_l_dim=m_l_dim->begin_list; local_l_dim; local_l_dim=local_l_dim->next){
+    size_t i = local_l_dim->index;
+    //char msg[50]; sprintf(msg, "dim[%ld] ",i);
+    //printDebug_dimension(&(local_l_dim->value), msg);
+    pconf->sz_layers[i]=local_l_dim->value.size;
+  //printf("debug: pconf->sz_layers[%ld]=%ld\n",i,pconf->sz_layers[i]);
+    pconf->array_dim_in_layers[i]=malloc((pconf->sz_layers[i])*sizeof(size_t));
+    for(size_t j=0; j< pconf->sz_layers[i];++j){
+      pconf->array_dim_in_layers[i][j] = local_l_dim->value.perm[j];
+  //printf("debug: pconf->array_dim_in_layers[%ld][%ld]=%ld\n",i,j,pconf->array_dim_in_layers[i][j]);
+    
+    }
+  }
+  return pconf;
+}
+
+void print_config_layers(config_layers * pconf){
+  for(size_t i=0;i<pconf->nb_layers; ++i){
+  //printf("debug: pconf->sz_layers[%ld]=%ld\n",i,pconf->sz_layers[i]);
+    for(size_t j=0; j< pconf->sz_layers[i];++j){
+  //printf(" [%ld][%ld]=%ld  | ",i,j,pconf->array_dim_in_layers[i][j]);
+    
+    }
+  //printf("debug: pconf->nb_layers=%ld\n",pconf->nb_layers);
+  }
+}
+
+void extract_src_score_date_from_filename(char *src, ssize_t score, size_t date, char *filename){
+  //
+}
+
 bool randomizeInitWeight=true;
 
 #define GEN_NEURONS_F_(type)\
+config_layers * create_config_layers_from_weight_in_neurons_##type(neurons_##type *base){\
+  config_layers *pconf=malloc(sizeof(struct config_layers));\
+  neurons_##type *tmp=base->next_layer;\
+  pconf->nb_layers=0;\
+  while(tmp){ ++(pconf->nb_layers); tmp=tmp->next_layer;}\
+  tmp=base->next_layer;\
+  pconf->sz_layers=malloc((pconf->nb_layers)*sizeof(size_t));\
+  pconf->array_dim_in_layers=malloc((pconf->nb_layers)*sizeof(size_t*));\
+  printf("debug: pconf->nb_layers=%ld\n",pconf->nb_layers);\
+  size_t layer=0;\
+  while(tmp){\
+    pconf->sz_layers[layer]=tmp->weight_in->dim->size;\
+  printf("debug: pconf->sz_layers[%ld]=%ld\n",layer,pconf->sz_layers[layer]);\
+    pconf->array_dim_in_layers[layer]=malloc((pconf->sz_layers[layer])*sizeof(size_t));\
+    for(size_t j=0;j<pconf->sz_layers[layer];++j){\
+      pconf->array_dim_in_layers[layer][j]=tmp->weight_in->dim->perm[j];\
+    }\
+    ++layer; tmp=tmp->next_layer;\
+  }\
+  return pconf;\
+}\
   \
 void do_not_update_learnig_rate_##type(neurons_##type *N){}\
 \
@@ -1033,6 +1127,66 @@ size_t learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##typ
   return nbreps;\
 }  \
 \
+\
+struct set_neurons_##type * create_set_neurons_##type(config_layers *pconf, struct neurons_##type *base, ssize_t score, size_t dateid){\
+  struct set_neurons_##type *p_set_n=malloc(sizeof(struct set_neurons_##type));\
+  p_set_n->pconf=pconf;\
+  p_set_n->base=base;\
+  p_set_n->score=score;\
+  p_set_n->dateid=dateid;\
+  return p_set_n;\
+}\
+\
+void free_set_neurons_##type(struct set_neurons_##type *p_s_nn){\
+  free_config_layers(p_s_nn->pconf);\
+  free_neurons_##type(p_s_nn->base);\
+  free(p_s_nn);\
+}\
+\
+GEN_LIST_ALL(ptr_set_NEURONS_##type)\
+GEN_FUNC_PTR_LIST_FREE(ptr_set_NEURONS_##type){\
+  ptr_set_NEURONS_##type p_s_nn = (struct set_neurons_##type *)arg;\
+  free_set_neurons_##type(p_s_nn);\
+}\
+\
+ssize_t sum_score_set_neurons_##type(struct main_list_ptr_set_NEURONS_##type *m_set_nrns){\
+  ssize_t sum_score=0;\
+  for(struct list_ptr_set_NEURONS_##type *local_set_n=m_set_nrns->begin_list; local_set_n ; local_set_n = local_set_n->next ){\
+    sum_score+=(local_set_n->value->score);\
+  }\
+  return sum_score;\
+}\
+void put_meaning_of_weitgh_in_set_neurons_##type(struct set_neurons_##type *dst_nrns, struct main_list_ptr_set_NEURONS_##type * m_set_nrns)\
+{\
+  ssize_t sum_score=0;\
+  for(struct list_ptr_set_NEURONS_##type *local_set_n=m_set_nrns->begin_list; local_set_n ; local_set_n = local_set_n->next ){\
+    sum_score+=(local_set_n->value->score);\
+    if(cmp_config_layers(dst_nrns->pconf, local_set_n->value->pconf)){\
+      printf("debug: config_layers not match in inex = %ld \n",local_set_n->index);\
+      return;\
+    }\
+  }\
+  struct neurons_##type *tmp_dst=dst_nrns->base;\
+  while(tmp_dst){\
+    for(size_t i=0; i<tmp_dst->weight_in->dim->size;++i){\
+    tmp_dst->weight_in->x[i]=0;\
+    }\
+    tmp_dst=tmp_dst->next_layer;\
+  }\
+  for(struct list_ptr_set_NEURONS_##type *local_set_n=m_set_nrns->begin_list; local_set_n ; local_set_n = local_set_n->next ){\
+    local_set_n->value->cur_neurons=local_set_n->value->base;\
+    tmp_dst=dst_nrns->base;\
+    while(tmp_dst){\
+      for(size_t i=0; i<tmp_dst->weight_in->dim->size;++i){\
+        tmp_dst->weight_in->x[i] +=(((local_set_n->value->score) * (local_set_n->value->cur_neurons->weight_in->x[i]))/sum_score);\
+      }\
+      tmp_dst=tmp_dst->next_layer;\
+      local_set_n->value->cur_neurons=local_set_n->value->cur_neurons->next_layer;\
+    }\
+  }\
+}\
+\
+\
 
  
   

neuron_t/src/neuron_t/neuron_t.h

@@ -7,6 +7,7 @@
 
 //#include "tools_t/tools_t.h"
 #include "tensor_t/tensor_t.h"
+#include "list_t/list_t.h"
 
 extern bool randomizeInitWeight;
 
@@ -19,7 +20,12 @@ typedef struct config_layers config_layers;
 config_layers *create_config_layers(size_t nb_layers, size_t *sz_layers, size_t **array_dim_in_layers);
 config_layers *create_config_layers_from_OneD(size_t nb_layers, size_t *array_dim_in_layers);
 void free_config_layers(config_layers *pconf);
+long int cmp_config_layers(config_layers *c1, config_layers *c2);
+config_layers * create_config_layers_from_m_list_ptr_DIMENSION(struct main_list_ptr_DIMENSION *m_l_dim);
+config_layers * create_config_layers_from_m_list_dimension(struct main_list_dimension *m_l_dim);
+void print_config_layers(config_layers * pconf);
 
+void extract_src_score_date_from_filename(char *src, ssize_t score, size_t date, char *filename);
 
 #define GEN_NEURON_(type)\
 \
@@ -52,6 +58,8 @@ struct neurons_##type {/* layer */\
 };\
 typedef struct neurons_##type neurons_##type;\
 \
+config_layers * create_config_layers_from_weight_in_neurons_##type(neurons_##type *base);\
+\
 struct func_act_##type {\
   type (*func_act)(type x); /* function activation */\
   type (*deriv_func_act)(type x); /* derivate func act */\
@@ -124,6 +132,24 @@ typedef struct cloneuronset_##type cloneuronset_##type;\
 void free_cloneuronset_##type(cloneuronset_##type *clnrnst);\
 cloneuronset_##type * create_cloneuronset_from_base_conf_##type(neurons_##type *base, config_layers *conf, size_t nb_clone);\
 size_t learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##type *dataset, bool (*condition)(type, size_t));\
+\
+\
+\
+struct set_neurons_##type{\
+  struct config_layers *pconf;\
+  struct neurons_##type *base;\
+  struct neurons_##type *cur_neurons;\
+  ssize_t score;\
+  size_t dateid;\
+};\
+typedef struct set_neurons_##type * ptr_set_NEURONS_##type;\
+\
+struct set_neurons_##type * create_set_neurons_##type(config_layers *pconf, struct neurons_##type *base, ssize_t score, size_t dateid);\
+\
+GENERATE_LIST_ALL(ptr_set_NEURONS_##type)\
+GEN_HEAD_PTR_LIST(ptr_set_NEURONS_##type)\
+\
+
 
 GEN_NEURON_(TYPE_FLOAT)
 GEN_NEURON_(TYPE_DOUBLE)

neuron_t/src/neuron_t/nneuron_t_file.h

@@ -443,9 +443,204 @@ j=0;\
 	if(dim) free_dimension(dim);\
 	if(l_p) free_list_perm_in_dim(l_p);\
 \
-}while(0);
+}while(0);\
+\
+\
+\
 
 
 
+#define EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(type, neuronDst, attribute, file_name_input, m_l_dim) \
+do{\
+  int fd_input;\
+  fd_input=open(file_name_input, O_RDONLY);\
+  if ( fd_input == -1 ) {\
+    fprintf( stderr, "Cannot open file: %s for reading\n",file_name_input );\
+    exit( -1 );\
+  }\
+  size_t buf_size=820;/*need to be more than the nb of char representation of the type*/\
+  char *input=malloc(buf_size + 1);\
+  char *recInput=malloc(buf_size + 1);\
+  memset(recInput,0, buf_size + 1);\
+  char *iinput=malloc(buf_size * 2);\
+  /*bool size_unknown=false, broken=false*/; \
+  bool Done=false;\
+  int retread = 0, curIn=0, lastNonNumber=0, lenRecIn=0;\
+\
+  list_perm_in_dim *l_p=NULL;\
+  dimension *dim=NULL;\
+  size_t ss;\
+  char *ttmp=NULL;\
+  char *ppEnd=NULL;\
+  bool bracketsDown=false/*, endTensor = false*/;\
+  size_t j=0;\
+  neurons_##type * tmpNN = neuronDst;\
+  tensor_##type * T=NULL;\
+  while(tmpNN /*&& !endTensor*/){\
+    bracketsDown = false;\
+    Done = false;\
+   /* T = tmpNN->attribute;\
+    if(T == NULL){\
+      Done = true;\
+    }*/\
+            T = tmpNN->attribute;\
+            while((T == NULL) && (tmpNN!=NULL)){\
+              tmpNN = tmpNN->next_layer;\
+              if(tmpNN)\
+                T = tmpNN->attribute;\
+            }\
+        /*printf("debug : dd ttmp = %s, T == NULL?=%d %s\n",ttmp,(T==NULL),#attribute);*/\
+            if(T == NULL){\
+              Done = true;\
+            } \
+j=0;\
+    while(!Done /*&& !endTensor*/){\
+      if(ttmp == NULL || *ttmp=='\0'){\
+        for(curIn=0; curIn<lenRecIn; ++curIn){\
+          iinput[curIn]=recInput[lenRecIn-curIn-1];\
+        }\
+        retread = read(fd_input, input, buf_size) ;\
+        /*endTensor = (retread != buf_size);*/\
+        /*printf("debug: ************************* ------>input = |%s|, retread=%d, input[ret-1]={%c}\n", input,retread,input[retread-1]);*/\
+        lenRecIn = 0;\
+        for(lastNonNumber=retread-1; lastNonNumber>=0; --lastNonNumber){ \
+          if(((input[lastNonNumber] >='0') && (input[lastNonNumber] <='9'))||(input[lastNonNumber] =='-')||(input[lastNonNumber] =='.')||(input[lastNonNumber] =='E')||(input[lastNonNumber] =='e')){\
+            recInput[lenRecIn++]=input[lastNonNumber];\
+          }\
+          else break;  \
+        }\
+        recInput[lenRecIn]='\0';\
+        /*printf("recInput = |%s|\n", recInput);*/\
+        for(int ii=0; ii<=lastNonNumber; ++ii){\
+          iinput[curIn++]=input[ii];\
+        }\
+        \
+        iinput[curIn]='\0';\
+        /*printf("iinput = |%s|\nDone=%d\n", iinput,Done);*/\
+        ttmp=iinput;\
+      }\
+      while(!Done && (*ttmp != '\0') /*&& !endTensor*/){\
+        /*printf("debug : >> ttmp = %s, bracketsDown=%d\n",ttmp, bracketsDown);*/\
+        if(*ttmp=='[') {\
+          bracketsDown=false;\
+        }\
+        ppEnd=ttmp;\
+        if( !bracketsDown){\
+          while(*ttmp!='\0' && *ppEnd!=']' ){\
+            if(*ttmp=='['){\
+        /*printf("debug : [[ ttmp = %s\n",ttmp);\
+   if(dim)printDebug_dimension(dim,"[DIM]");*/\
+              if(l_p != NULL){\
+                free_dimension(dim);\
+                free_list_perm_in_dim(l_p);\
+                l_p=NULL;\
+              }\
+   /*if(dim)printDebug_dimension(dim,"{DIM}");*/\
+            }\
+            ss = strtoul(ttmp, &ppEnd, 10);\
+            while(ttmp == ppEnd && *ttmp!='\0'  && ppEnd[0] !=']'){\
+             \
+             if(*ttmp=='['){\
+        /*printf("debug : [[ ttmp = %s\n",ttmp);\
+   if(dim)printDebug_dimension(dim,"[DIM]");*/\
+              if(l_p != NULL){\
+                free_dimension(dim);\
+                free_list_perm_in_dim(l_p);\
+                l_p=NULL;\
+              }\
+   /*if(dim)printDebug_dimension(dim,"{DIM}");*/\
+            }\
+             \
+        /*printf("debug : aa ttmp = %s\n",ttmp);*/\
+              ttmp++;\
+              ss = strtoul(ttmp, &ppEnd, 10);\
+        /*printf("debug : bb ttmp = %s\n",ttmp);*/\
+            }\
+            if(ppEnd !=ttmp ){\
+              append_in_list_perm(&l_p,ss);\
+            }\
+            ttmp=ppEnd;\
+          }\
+        /*printf("debug : cc ttmp = %s\n",ttmp);*/\
+          if( *ttmp ==']'){\
+            dim=create_dim_from_list_perm(l_p);\
+            push_back_list_ptr_DIMENSION(m_l_dim, clone_dim(dim));\
+            /*push_back_list_dimension(m_l_dim, *dim);*/\
+            bracketsDown = true;\
+     printf("debug: dim ptr: %p sizeof(*dim)=%ld sizeof(dimension)=%ld\n",dim,sizeof(*dim), sizeof(dimension));\
+   if(dim){printDebug_dimension(dim,"{DIM}");}\
+            j=0;\
+            \
+          }\
+        \
+        }\
+        /*printf("debug : <<---->> ttmp = %s, bracketsDown=%d T==NULL? =%d, done?=%d\n",ttmp, bracketsDown, (T==NULL), Done);*/\
+        if(!Done && bracketsDown){\
+        /*printf("debug : ee ttmp = %s, T==NULL ? = %d\n %ld vs %ld\n",ttmp,(T==NULL),T->dim->rank,dim->rank);\
+   printDebug_dimension(dim," DIM");*/\
+          if((T->dim->rank == dim->rank)){\
+            \
+            \
+          \
+            type x;\
+            while(strlen(ttmp) && (*ttmp!='[') && (j<dim->rank)){ \
+              x = strto_##type(ttmp, &ppEnd);\
+              while(ttmp == ppEnd && strlen(ttmp) && *ttmp!='[' ){\
+        /*printf("debug : dd ttmp = %s\n",ttmp);*/\
+                ttmp++;\
+                x = strto_##type(ttmp, &ppEnd);\
+        /*printf("debug : ww ttmp = %s\n",ttmp);*/\
+              }\
+              if((*ttmp!='[') && (ttmp != ppEnd)){\
+                T->x[j++]=x;\
+                /*printf("debug : x=%lf ===> %d\n",x,(j==dim->rank));*/\
+              }\
+              else if ( *ttmp =='[') {\
+                bracketsDown = false;\
+                Done=true;\
+                break;\
+              }\
+              ttmp=ppEnd;\
+              Done=(j==dim->rank);\
+              /*endTensor=(j==dim->rank);*/\
+            }\
+            if(Done) break;\
+            if(j == dim->rank ){\
+              Done = true;\
+            }\
+          }else {\
+            /*endTensor = true;*/\
+            /*Done = true;\
+            bracketsDown = false;*/\
+            break;\
+          }\
+        }\
+          if(Done){\
+                /*printf("debug : done=%d , l_p==NULL?=%d, endTensor=%d\n",Done, (l_p==NULL), endTensor);*/\
+            if(l_p != NULL){\
+              free_dimension(dim);\
+							dim=NULL;\
+              free_list_perm_in_dim(l_p);\
+              l_p=NULL;\
+            }\
+          }\
+          \
+      }\
+      if(Done) break;\
+  \
+    }\
+    tmpNN = tmpNN->next_layer;\
+  }\
+  free(input);\
+  free(iinput);\
+  free(recInput);\
+  close(fd_input);\
+	if(dim) free_dimension(dim);\
+	if(l_p) free_list_perm_in_dim(l_p);\
+\
+}while(0);\
+\
+\
+\
 
 #endif /* NNEURONE_T_FILE_H__C_ */

tensor_t/src/tensor_t/tensor_t.c

@@ -671,7 +671,7 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
-        getchar();\
+        /*getchar();*/\
     }\
 \
     size_t len0 = M0->dim->size - contractionNumber;\
@@ -736,6 +736,94 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
     }\
     FREE_dM_S_ \
 }\
+\
+/* M[x0,x1,x3..xn] X M[y0,y1,y3..ym] = M[z0,z1...zp] (deep = l > 0) /exists 1<= l<...<l=n /  xl = y0,x{l+1}=y1, x{n}=yl  et zi=xi i<n-l et zj=y{j-(n-l)} j>=n-l alor p=n+m-2l\
+ M[x0,x1,x3..xl x{l+1}...xn] X M[xn,x{n-1},x{n-2}...xl y{l+1} ..ym] = M[x0,x1..xly{l+1}...y{n+m-2l}] (deep = l > 0)\
+M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
+\
+void tensorContractnProdOpt0_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
+   /* if (!checkMatchProdtensor(M0->dim, M1->dim, contractionNumber)) {\
+        prsize_tf("Deep = %d\n", contractionNumber);\
+    }*/\
+    if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
+      printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
+        printDebug_dimension(M0->dim, "M0 dim");\
+        printDebug_dimension(M1->dim, "M1 dim");\
+        /*getchar();*/\
+    }\
+\
+    size_t len0 = M0->dim->size - contractionNumber;\
+    size_t len1 = M1->dim->size - contractionNumber;\
+\
+    size_t* tsub0 = malloc(sizeof(size_t) *len0);\
+    size_t* tsub1 = malloc(sizeof(size_t) *len1);\
+    size_t* tDk1 = malloc(sizeof(size_t) *contractionNumber);\
+    size_t* tDk0 = malloc(sizeof(size_t) *contractionNumber);\
+    subArray(tsub0, M0->dim->perm, 0, len0, 0);\
+    subArray(tsub1, M1->dim->perm, 0, len1, contractionNumber);\
+    subArray(tDk1, M1->dim->perm, 0, contractionNumber, 0);\
+    subArray(tDk0, M0->dim->perm, 0, contractionNumber, len0);\
+    /*printArraySzt(tsub0,len0,"tsub0");\
+    printArraySzt(tsub1,len1,"tsub1");\
+    printArraySzt(tDk0,contractionNumber,"tDk0");\
+    printArraySzt(tDk1,contractionNumber,"tDk1");*/\
+    dimension *dSub0 = init_dim(tsub0, len0);\
+    dimension *dSub1 = init_dim(tsub1, len1);\
+    dimension *dM1 = init_dim(tDk1, contractionNumber);\
+    dimension *dM0 = init_dim(tDk0, contractionNumber);\
+  /*printDebug_dimension(dSub0,"dSub0");\
+  printDebug_dimension(dSub1,"dSub1");\
+  printDebug_dimension(dM0,"dM0");\
+  printDebug_dimension(dM1,"dM1");*/\
+    dimension *dM;\
+    min_copy_dimension(&dM, dM0, dM1);\
+  /*printDebug_dimension(dM,"dM");*/\
+    \
+    dimension *dd;\
+    add_dimension(&dd, dSub0, dSub1);\
+  /*printDebug_dimension(dd,"dd");*/\
+    updateRankDim(dd);\
+    _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
+    tensor_##type *M= *MM;\
+\
+   \
+\
+    size_t a0_id, a1_id, n0_id, n1_id;\
+    for (size_t i = 0; i < M->dim->rank; i++) {\
+        if(endian){\
+          a0_id=i/dSub1->rank;\
+          a1_id=i%dSub1->rank;\
+          n0_id=a0_id*dM->rank ;\
+          n1_id= a1_id ;\
+        }\
+        else{\
+          a0_id=i%dSub0->rank;\
+          a1_id=i/dSub0->rank;\
+          n1_id= a1_id*dM->rank ;\
+          n0_id= a0_id ;\
+        }\
+        M->x[i] = 0;\
+        for (size_t k = 0; k < dM->rank; k++) {\
+          if(endian){\
+            /*n0_id= a0_id*dM->rank + k;*/\
+            /*n1_id= a1_id + dSub1->rank * k;*/\
+            /*M->x[i] += M0->x[begin0++] * M1->x[n1_id];*/\
+            M->x[i] += M0->x[n0_id++] * M1->x[n1_id];\
+            n1_id +=dSub1->rank ;\
+          }\
+          else{\
+            /*n0_id= a0_id + dSub0->rank * k;*/\
+            /*n1_id= a1_id*dM->rank + k;*/\
+            /*M->x[i] += M0->x[n0_id] * M1->x[begin1++];*/\
+            M->x[i] += M0->x[n0_id] * M1->x[n1_id++];\
+            n0_id += dSub0->rank ;\
+          }\
+            \
+        }\
+    }\
+    FREE_dM_S_ \
+}\
+\
 struct arg_Prod_##type{\
   type *M0x;\
   type *M1x;\
@@ -904,7 +992,7 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
-        getchar();\
+        /*getchar();*/\
     }\
     size_t len0 = M0->dim->size - contractionNumber;\
     size_t len1 = M1->dim->size - contractionNumber;\
@@ -963,6 +1051,103 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
   FREE_dM_S_ ; \
 }\
 \
+\
+void* runProdContractOpt0_thread_##type(void *arg){\
+  struct arg_ProdContract_##type *arg_t = arg;\
+  size_t a0_id, a1_id, n0_id, n1_id;\
+    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+        if(endian){\
+          a0_id=i/ arg_t->dSubRank;\
+          a1_id=i% arg_t->dSubRank;\
+            n0_id= a0_id * arg_t->dMRank ;\
+            n1_id= a1_id ;\
+        }\
+        else{\
+          a0_id=i% arg_t->dSubRank;\
+          a1_id=i/ arg_t->dSubRank;\
+            n0_id= a0_id ;\
+            n1_id= a1_id * arg_t->dMRank ;\
+        }\
+        arg_t->Mx[i] = 0;\
+        for (size_t k = 0; k < arg_t->dMRank; k++) {\
+          if(endian){\
+            arg_t->Mx[i] += arg_t->M0x[n0_id++] * arg_t->M1x[n1_id];\
+            n1_id += arg_t->dSubRank ;\
+          }\
+          else{\
+            arg_t->Mx[i] += arg_t->M0x[n0_id] * arg_t->M1x[n1_id];\
+            n0_id += arg_t->dSubRank ;\
+          }\
+        }\
+    }\
+  return 0;\
+}\
+\
+\
+void tensorContractnProdThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
+    if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
+      printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
+        printDebug_dimension(M0->dim, "M0 dim");\
+        printDebug_dimension(M1->dim, "M1 dim");\
+        /*getchar();*/\
+    }\
+    size_t len0 = M0->dim->size - contractionNumber;\
+    size_t len1 = M1->dim->size - contractionNumber;\
+\
+    size_t* tsub0 = malloc(sizeof(size_t) *len0);\
+    size_t* tsub1 = malloc(sizeof(size_t) *len1);\
+    size_t* tDk1 = malloc(sizeof(size_t) *contractionNumber);\
+    size_t* tDk0 = malloc(sizeof(size_t) *contractionNumber);\
+    subArray(tsub0, M0->dim->perm, 0, len0, 0);\
+    subArray(tsub1, M1->dim->perm, 0, len1, contractionNumber);\
+    subArray(tDk1, M1->dim->perm, 0, contractionNumber, 0);\
+    subArray(tDk0, M0->dim->perm, 0, contractionNumber, len0);\
+    dimension *dSub0 = init_dim(tsub0, len0);\
+    dimension *dSub1 = init_dim(tsub1, len1);\
+    dimension *dM1 = init_dim(tDk1, contractionNumber);\
+    dimension *dM0 = init_dim(tDk0, contractionNumber);\
+    dimension *dM;\
+    min_copy_dimension(&dM, dM0, dM1);\
+    \
+    dimension *dd;\
+    add_dimension(&dd, dSub0, dSub1);\
+    updateRankDim(dd);\
+    _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
+    tensor_##type *M= *MM;\
+\
+\
+    \
+  pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
+  struct arg_ProdContract_##type **arg_th = malloc( nbthread * sizeof(struct arg_ProdContract_##type *));\
+\
+  for(size_t i = 0; i < nbthread; ++i){\
+    arg_th[i]=malloc(sizeof(struct arg_ProdContract_##type));\
+    arg_th[i]->M0x=M0->x;\
+    arg_th[i]->M1x=M1->x;\
+    arg_th[i]->Mx=M->x;\
+    arg_th[i]->beginRange = i*(M->dim->rank)/nbthread ;\
+    if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\
+    else arg_th[i]->endRange = M->dim->rank ;\
+    if(endian){\
+      arg_th[i]->dSubRank = dSub1->rank;\
+    }\
+    else{\
+      arg_th[i]->dSubRank = dSub0->rank;\
+    }\
+    arg_th[i]->dMRank = dM->rank;\
+    pthread_create(&thrd[i], NULL, runProdContractOpt0_thread_##type, (void*)arg_th[i]);\
+  }\
+\
+  for(size_t i=0; i< nbthread; ++i){\
+    pthread_join(thrd[i], NULL);\
+    free(arg_th[i]);\
+  }\
+\
+  free(thrd);\
+  free(arg_th);\
+  FREE_dM_S_ ; \
+}\
+\
 struct arg_Pro2dContract_##type{\
   type *M0x;\
   type *M1x;\
@@ -973,6 +1158,7 @@ struct arg_Pro2dContract_##type{\
   size_t dSub0Rank;\
   size_t dSub1Rank;\
 };\
+\
 void* runPro2dContract_thread_##type(void *arg){\
   struct arg_Pro2dContract_##type *arg_t = arg;\
   size_t n0_id, n1_id, l;\
@@ -1010,7 +1196,7 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
-        getchar();\
+        /*getchar();*/\
     }\
 \
     size_t len0 = M0->dim->size - contractionNumber;\
@@ -1064,12 +1250,112 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
   free(arg_th);\
   FREE_dM_S_ ; \
 }\
+\
+void* runPro2dContractOpt0_thread_##type(void *arg){\
+  struct arg_Pro2dContract_##type *arg_t = arg;\
+  size_t n0_id, n1_id, l;\
+    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+      for (size_t j = 0; j < arg_t->dSub1Rank; j++) {\
+        if(endian){\
+          l = j + arg_t->dSub1Rank * i;\
+            n0_id= i * arg_t->dMRank ;\
+            n1_id= j ;\
+        }else{\
+          l = j * arg_t->dSub0Rank + i;\
+            n0_id= i ;\
+            n1_id= j * arg_t->dMRank ;\
+        }\
+        arg_t->Mx[l] = 0;\
+        for (size_t k = 0; k < arg_t->dMRank; k++) {\
+          if(endian){\
+            /*n0_id= i * arg_t->dMRank + k;\
+            n1_id= j + arg_t->dSub1Rank * k;*/\
+            arg_t->Mx[l] += arg_t->M0x[n0_id++] * arg_t->M1x[n1_id];\
+            n1_id += arg_t->dSub1Rank ;\
+          }\
+          else{\
+            /*n0_id= i + arg_t->dSub0Rank * k;\
+            n1_id= j * arg_t->dMRank + k;*/\
+            arg_t->Mx[l] += arg_t->M0x[n0_id] * arg_t->M1x[n1_id];\
+            n0_id += arg_t->dSub0Rank ;\
+          }\
+        }\
+      }\
+    }\
+  return 0;\
+}\
+/* M[x0,x1,x3..xn] X M[y0,y1,y3..ym] = M[z0,z1...zp] (deep = l > 0) /exists 1<= l<...<l=n /  xl = y0,x{l+1}=y1, x{n}=yl  et zi=xi i<n-l et zj=y{j-(n-l)} j>=n-l alor p=n+m-2l\
+ M[x0,x1,x3..xl x{l+1}...xn] X M[xn,x{n-1},x{n-2}...xl y{l+1} ..ym] = M[x0,x1..xly{l+1}...y{n+m-2l}] (deep = l > 0)\
+M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
+\
+void tensorContractnPro2dThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
+    /*if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
+      printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
+    }*/\
+    if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
+      printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
+        printDebug_dimension(M0->dim, "M0 dim");\
+        printDebug_dimension(M1->dim, "M1 dim");\
+        /*getchar();*/\
+    }\
+\
+    size_t len0 = M0->dim->size - contractionNumber;\
+    size_t len1 = M1->dim->size - contractionNumber;\
+\
+    size_t* tsub0 = malloc(sizeof(size_t) *len0);\
+    size_t* tsub1 = malloc(sizeof(size_t) *len1);\
+    size_t* tDk1 = malloc(sizeof(size_t) *contractionNumber);\
+    size_t* tDk0 = malloc(sizeof(size_t) *contractionNumber);\
+    subArray(tsub0, M0->dim->perm, 0, len0, 0);\
+    subArray(tsub1, M1->dim->perm, 0, len1, contractionNumber);\
+    subArray(tDk1, M1->dim->perm, 0, contractionNumber, 0);\
+    subArray(tDk0, M0->dim->perm, 0, contractionNumber, len0);\
+    dimension *dSub0 = init_dim(tsub0, len0);\
+    dimension *dSub1 = init_dim(tsub1, len1);\
+    dimension *dM1 = init_dim(tDk1, contractionNumber);\
+    dimension *dM0 = init_dim(tDk0, contractionNumber);\
+    dimension *dM;\
+    min_copy_dimension(&dM, dM0, dM1);\
+    \
+    dimension *dd;\
+    add_dimension(&dd, dSub0, dSub1);\
+    updateRankDim(dd);\
+    _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
+    tensor_##type *M= *MM;\
+\
+\
+    \
+  pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
+  struct arg_Pro2dContract_##type **arg_th = malloc( nbthread * sizeof(struct arg_Pro2dContract_##type *));\
+\
+  for(size_t i = 0; i < nbthread; ++i) {\
+    arg_th[i] = malloc(sizeof(struct arg_Pro2dContract_##type));\
+    arg_th[i]->M0x=M0->x;\
+    arg_th[i]->M1x=M1->x;\
+    arg_th[i]->Mx=M->x;\
+    arg_th[i]->beginRange = i*(dSub0->rank)/nbthread ;\
+    arg_th[i]->endRange = (i+1)*(dSub0->rank)/nbthread ;\
+    arg_th[i]->dSub1Rank = dSub1->rank;\
+    arg_th[i]->dSub0Rank = dSub0->rank;\
+    arg_th[i]->dMRank = dM->rank;\
+    pthread_create(&thrd[i], NULL, runPro2dContractOpt0_thread_##type, (void*)arg_th[i]);\
+  }\
+\
+  for(size_t i=0; i< nbthread; ++i){\
+    pthread_join(thrd[i], NULL);\
+    free(arg_th[i]);\
+  }\
+\
+  free(thrd);\
+  free(arg_th);\
+  FREE_dM_S_ ; \
+}\
 void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
     if (!checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)) {\
         printf("error Deep = %ld\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
-        getchar();\
+        /*getchar();*/\
     }\
     size_t len0 = M0->dim->size - contractionNumber;\
     size_t len1 = M1->dim->size - contractionNumber;\
@@ -1691,6 +1977,40 @@ tensor_##type * transpose_notOpt_tensor_##type(tensor_##type *org){\
   return tens_tr;\
 }\
 \
+tensor_##type * transpose_Opt0_tensor_##type(tensor_##type *org){\
+  size_t dimsz = (org->dim)->size; \
+  dimension *dim_tr=create_dim(dimsz);\
+  for(size_t i=0; i<dimsz; ++i) dim_tr->perm[i]=(org->dim)->perm[(dimsz-1)-i];\
+  updateRankDim(dim_tr);\
+  printDebug_dimension(dim_tr,"dim_trOpt");\
+  tensor_##type *tens_tr = CREATE_TENSOR_##type(dim_tr);\
+  long int base_i[dimsz+1];/* = (org->dim)->size;*/ \
+	base_i[dimsz]=1;/*(org->dim)->perm[dimsz-1];*/\
+	/*printf("DEBUG: base_i[%ld]=%ld\n",dimsz,base_i[dimsz]);*/\
+  for(long int j=dimsz-1; j>=0; --j) { \
+		base_i[j] =base_i[j+1]*(org->dim)->perm[j];\
+		/*printf("DEBUG: base_i[%ld]=%ld\n",j,base_i[j]);*/\
+	}\
+	long int cur_tr=0, add_tr=0, minus_tr=0;\
+	tens_tr->x[cur_tr] = org->x[cur_tr];\
+  for(size_t i=1; i<dim_tr->rank; ++i){\
+		minus_tr =0;\
+		/*printf("DEBUG: cur_tr=%ld\n",cur_tr);*/\
+		for(size_t l=0; l<dimsz; ++l){			\
+			add_tr = minus_tr + base_i[l+1];\
+			if(cur_tr + add_tr < base_i[l]){\
+				cur_tr += add_tr;\
+				/*tens_tr->x[cur_tr] = org->x[i]*/;\
+				tens_tr->x[i] = org->x[cur_tr];\
+				break;\
+			}\
+			minus_tr -= (base_i[l]-base_i[l+1]);\
+		}\
+		/*printf("DEBUG: after cur_tr=%ld\n",cur_tr);*/\
+  }\
+  return tens_tr;\
+}\
+\
 tensor_##type * permute_notOpt_tensor_##type(tensor_##type *org, dimension *dperm){\
   size_t dimsz = (org->dim)->size; \
   dimension *dim_tr=create_dim(dimsz);\

tensor_t/src/tensor_t/tensor_t.h

@@ -40,8 +40,11 @@ void tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##
 void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1,size_t nbthread); \
 void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1,size_t nbthread); \
 void tensorContractnProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread); \
+void tensorContractnProdThreadOpt0_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread); \
 void tensorContractnPro2dThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread); \
+void tensorContractnPro2dThreadOpt0_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread); \
 void tensorContractnProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \
+void tensorContractnProdOpt0_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \
 type scalarProduct_dep_contractProd_##type(tensor_##type *M0, tensor_##type *M1, size_t nbthreads ,void (*tensorContractVar)(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread ));\
 type scalarProduct_0_##type(tensor_##type *M0, tensor_##type *M1);\
 void init_random_x_##type(tensor_##type *M, type minR, type maxR,  int randomRange);\
@@ -59,6 +62,7 @@ void append_array_chainlist_##type(array_chainlist_##type **list_a, type x);\
 tensor_##type * create_tensor_from_list_array_##type( array_chainlist_##type *l_a, dimension *part_dim);\
 void free_array_chainlist_##type(array_chainlist_##type *l_a);\
 tensor_##type * transpose_notOpt_tensor_##type(tensor_##type *org);\
+tensor_##type * transpose_Opt0_tensor_##type(tensor_##type *org);\
 tensor_##type * permute_notOpt_tensor_##type(tensor_##type *org, dimension *dperm);\
 void update_1tensor_func_##type(tensor_##type *M0, \
     type (*func)(type), size_t nbthread);\

tensor_t/test/Makefile

@@ -7,11 +7,12 @@ CC=gcc
 ROOT_DIR=$(PWD)
 YTESTDIR=$(ROOTPROJECTDIR)/ytest_t
 YPERMDIR=$(ROOTPROJECTDIR)/ypermutation_t
+LISTDIR=$(ROOTPROJECTDIR)/list_t
 
 TENSDIR=$(ROOTPROJECTDIR)/tensor_t
 DIMDIR=$(ROOTPROJECTDIR)/dimension_t
 INCLUDE_DIR=$(TENSDIR)/src
-CFLAGS=-I$(INCLUDE_DIR) -I$(YPERMDIR)/src -I$(YTESTDIR)/include_ytest/include -I$(DIMDIR)/src -I$(TENSDIR)/src #"-D DEBUG=1"
+CFLAGS=-I$(INCLUDE_DIR) -I$(YPERMDIR)/src -I$(YTESTDIR)/include_ytest/include -I$(DIMDIR)/src -I$(TENSDIR)/src -I$(LISTDIR)/src #"-D DEBUG=1"
 LDFLAGS=-L$(YTESTDIR) -lytest -lOpenCL
 
 #SRC_DIR=$(ROOT_DIR)/src

tensor_t/test/is_good.c

@@ -911,7 +911,7 @@ TEST(tensorContractnProd_TYPE_FLOATNoOpt3endianFalse ){
   d0->perm[1]=2; //3;
   d0->perm[2]=3;
 
-  d1->perm[0]=4;
+  d1->perm[0]=3;
   d1->perm[1]=2;//3;
   d1->perm[2]=5;
 
@@ -922,7 +922,7 @@ TEST(tensorContractnProd_TYPE_FLOATNoOpt3endianFalse ){
   d0->perm[1]=12; //3;
   d0->perm[2]=35;
 
-  d1->perm[0]=32;
+  d1->perm[0]=35;
   d1->perm[1]=12;//3;
   d1->perm[2]=13;
 #endif
@@ -1098,13 +1098,13 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
 #else
 
 
-  d0->perm[0]=35;
+  d0->perm[0]=335;
   d0->perm[1]=32; //3;
-  d0->perm[2]=23;
+  d0->perm[2]=43;
 
   d1->perm[0]=32;
-  d1->perm[1]=23;//3;
-  d1->perm[2]=44;
+  d1->perm[1]=43;//3;
+  d1->perm[2]=244;
 #endif
 
   updateRankDim(d0);
@@ -1135,7 +1135,7 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
   // for(size_t i=0;i<M->dim->rank;++i)
   //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
     
-  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
   free_tensor_TYPE_FLOAT(M);
   free_tensor_TYPE_FLOAT(MnO);
@@ -1143,6 +1143,370 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
   free_tensor_TYPE_FLOAT(M1);
 
 }
+
+TEST(tensorContractnProdOpt0_TYPE_FLOAT2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=2;
+  d1->perm[1]=3;//3;
+  d1->perm[2]=8;
+
+#else
+
+
+  d0->perm[0]=335;
+  d0->perm[1]=32; //3;
+  d0->perm[2]=43;
+
+  d1->perm[0]=32;
+  d1->perm[1]=43;//3;
+  d1->perm[2]=244;
+#endif
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  tensorContractnProdOpt0_TYPE_FLOAT(&M, M0,M1,2);
+//  print_tensor_float(M,"M");
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+
+//  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+
+
+TEST(tensorContractnProdThreadOpt0_TYPE_FLOAT2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=2;
+  d1->perm[1]=3;//3;
+  d1->perm[2]=8;
+
+#else
+
+
+  d0->perm[0]=335;
+  d0->perm[1]=32; //3;
+  d0->perm[2]=43;
+
+  d1->perm[0]=32;
+  d1->perm[1]=43;//3;
+  d1->perm[2]=244;
+#endif
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  tensorContractnProdThreadOpt0_TYPE_FLOAT(&M, M0,M1,2,8);
+//  print_tensor_float(M,"M");
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+
+//  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+
+TEST(tensorContractnPro2dThreadOpt0_TYPE_FLOAT2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=2;
+  d1->perm[1]=3;//3;
+  d1->perm[2]=8;
+
+#else
+
+
+  d0->perm[0]=335;
+  d0->perm[1]=32; //3;
+  d0->perm[2]=43;
+
+  d1->perm[0]=32;
+  d1->perm[1]=43;//3;
+  d1->perm[2]=244;
+#endif
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  tensorContractnPro2dThreadOpt0_TYPE_FLOAT(&M, M0,M1,2,8);
+//  print_tensor_float(M,"M");
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+
+//  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+
+TEST(tensorContractnPro2dThread_TYPE_FLOAT2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=2;
+  d1->perm[1]=3;//3;
+  d1->perm[2]=8;
+
+#else
+
+
+  d0->perm[0]=335;
+  d0->perm[1]=32; //3;
+  d0->perm[2]=43;
+
+  d1->perm[0]=32;
+  d1->perm[1]=43;//3;
+  d1->perm[2]=244;
+#endif
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  tensorContractnPro2dThread_TYPE_FLOAT(&M, M0,M1,2,8);
+//  print_tensor_float(M,"M");
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+
+//  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+
+
+
+TEST(tensorContractnProdThread_TYPE_FLOAT2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=2;
+  d1->perm[1]=3;//3;
+  d1->perm[2]=8;
+
+#else
+
+
+  d0->perm[0]=335;
+  d0->perm[1]=32; //3;
+  d0->perm[2]=43;
+
+  d1->perm[0]=32;
+  d1->perm[1]=43;//3;
+  d1->perm[2]=244;
+#endif
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  tensorContractnProdThread_TYPE_FLOAT(&M, M0,M1,2,8);
+//  print_tensor_float(M,"M");
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+
+//  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+TEST(tensorContractnProd_TYPE_DOUBLE_2_1 ){
+  dimension *d0=create_dim(2);
+  dimension *d1=create_dim(1);
+#if VALGRIND_
+  d0->perm[0]=4;
+  d0->perm[1]=2; //3;
+
+  d1->perm[0]=2;
+
+#else
+
+  d0->perm[0]=125;
+  d0->perm[1]=52; //3;
+
+  d1->perm[0]=52;
+#endif
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_double(M0,"M0");
+  print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M=NULL;
+  tensor_TYPE_DOUBLE *MnO=NULL;
+
+  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,1);
+  //print_tensor_double(M,"M");
+  //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+  tensorContractnProdNotOpt_TYPE_DOUBLE(&MnO, M0,M1,1);
+
+  print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+}
+
+
+
 TEST(tensorContractnProd_TYPE_DOUBLE_2_1 ){
   dimension *d0=create_dim(2);
   dimension *d1=create_dim(1);
@@ -1804,6 +2168,67 @@ TEST(transpose_parseInput_unknownpart_to_tensor){
   free_tensor_TYPE_FLOAT(t);
   free_tensor_TYPE_FLOAT(transpose);
 }
+TEST(transpose_input_to_OpT_Ranspose){
+  endian=true;
+  char *input="[*,3]"\
+               "((1.1,1.2,1.3)"\
+               "((2.1,2.2,2.3)"\
+               "((3.1,3.2,3.3)"\
+               "((4.1,4.2,4.3)"\
+               "((5.1,5.2,5.3)"\
+               "((6.1,6.2,6.3)"\
+               "(7.1,7.2,7.3)) ";
+
+  tensor_TYPE_FLOAT *t=parseInput_withDim_to_tensor_TYPE_FLOAT(input);
+
+  print_tensor_msg_TYPE_FLOAT(t," tensor from input" );
+
+
+  tensor_TYPE_FLOAT *transpose = transpose_notOpt_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose," transpose from input" );
+  tensor_TYPE_FLOAT *transpose_Opt0 = transpose_Opt0_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose_Opt0," transpose_Opt0 from input" );
+
+	EXPECT_ARRAY_EQ_TYPE_FLOAT(transpose->x,transpose->dim->rank ,transpose_Opt0->x,transpose_Opt0->dim->rank);
+
+  free_tensor_TYPE_FLOAT(t);
+  free_tensor_TYPE_FLOAT(transpose);
+  free_tensor_TYPE_FLOAT(transpose_Opt0);
+}
+
+TEST(transpose_input_to_OpT_Ranspose2){
+  endian=true;
+  char *input="[*,4,3]"\
+               "(((1.11,1.12,1.13),(1.21,1.22,1.23),(1.31,1.32,1.33),(1.41,1.42,1.43)),"\
+               "((2.11,2.12,2.13),(2.21,2.22,2.23),(2.31,2.32,2.33),(2.41,2.42,2.43)),"\
+               "((3.11,3.12,3.13),(3.21,3.22,3.23),(3.31,3.32,3.33),(3.41,3.42,3.43)),"\
+               "((4.11,4.12,4.13),(4.21,4.22,4.23),(4.31,4.32,4.33),(4.41,4.42,4.43)),"\
+               "((5.11,5.12,5.13),(5.21,5.22,5.23),(5.31,5.32,5.33),(5.41,5.42,5.43)),"\
+               "((6.11,6.12,6.13),(6.21,6.22,6.23),(6.31,6.32,6.33),(6.41,6.42,6.43)),"\
+               "((7.11,7.12,7.13),(7.21,7.22,7.23),(7.31,7.32,7.33),(7.41,7.42,7.43)),"\
+               "((8.11,8.12,8.13),(8.21,8.22,8.23),(8.31,8.32,8.33),(8.41,8.42,8.43)),"\
+               "((9.11,9.12,9.13),(9.21,9.22,9.23),(9.31,9.32,9.33),(9.41,9.42,9.43)),"\
+               "((10.11,10.12,10.13),(10.21,10.22,10.23),(10.31,10.32,10.33),(10.41,10.42,10.43)),"\
+               "((11.11,11.12,11.13),(11.21,11.22,11.23),(11.31,11.32,11.33),(11.41,11.42,11.43)),"\
+               "((12.11,12.12,12.13),(12.21,12.22,12.23),(12.31,12.32,12.33),(12.41,12.42,12.43)),"\
+               "((13.11,13.12,13.13),(13.21,13.22,13.23),(13.31,13.32,13.33),(13.41,13.42,13.43)))";
+
+  tensor_TYPE_FLOAT *t=parseInput_withDim_to_tensor_TYPE_FLOAT(input);
+
+  print_tensor_msg_TYPE_FLOAT(t," tensor from input" );
+
+
+  tensor_TYPE_FLOAT *transpose = transpose_notOpt_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose," transpose from input" );
+  tensor_TYPE_FLOAT *transpose_Opt0 = transpose_Opt0_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose_Opt0," transpose_Opt0 from input" );
+
+	EXPECT_ARRAY_EQ_TYPE_FLOAT(transpose->x,transpose->dim->rank ,transpose_Opt0->x,transpose_Opt0->dim->rank);
+
+  free_tensor_TYPE_FLOAT(t);
+  free_tensor_TYPE_FLOAT(transpose);
+  free_tensor_TYPE_FLOAT(transpose_Opt0);
+}
 TEST(permute_parseInput_unknownpart_to_tensor){
   endian=true;
   char *input="[*,3]"\

y_network_neural_network_/test/Makefile

@@ -23,8 +23,9 @@ YLISTDIR=$(ROOTPROJECTDIR)/list_t
 YWORKDIR=$(ROOTPROJECTDIR)/y_worker_t
 YJSONDIR=$(ROOTPROJECTDIR)/yjson_t
 YSOCKET_DIR=$(ROOTPROJECTDIR)/y_socket_t
+#DIMENSIONDIR=$(ROOTPROJECTDIR)/dimension_t
 
-INCLUDE_SOCKET=-I$(YSOCKET_DIR)/include -I$(YLISTDIR)/src -I$(YWORKDIR)/include -I$(YJSONDIR)/src -I$(YSOCKET_DIR)/include 
+INCLUDE_SOCKET=-I$(YSOCKET_DIR)/include -I$(YLISTDIR)/src -I$(YWORKDIR)/include -I$(YJSONDIR)/src -I$(YSOCKET_DIR)/include #-I$(DIMENSIONDIR)/src
 
 LIB_SOCKET=$(YSOCKET_DIR)/libysocket.so
 

y_network_neural_network_/test/is_good.c

@@ -14,6 +14,7 @@
 #include "fmock/fmock.h"
 
 #include "neuron_t/neuron_t.h"
+//#include "dimension_t/dimension_t.h"
 
 #include "vehicle.h"
 #include "learn_to_drive.h"
@@ -772,8 +773,764 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
 
 }
 
+TEST(extract_with_pconf){
+  size_t nb_block = 7;
+  size_t dim= 2;
+  struct blocks * path = create_blocks(nb_block, dim);
+
+  LOG("debug: f_name = %s\n", __func__);
+
+#if 0
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[0], (float[]){100,250});
+  copy_coordinate(path->lower_bound_block[1], (float[]){100,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){250,80});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,0});
+  copy_coordinate(path->upper_bound_block[2], (float[]){360,140});
+  copy_coordinate(path->lower_bound_block[3], (float[]){360,70});
+  copy_coordinate(path->upper_bound_block[3], (float[]){600,140});
+  copy_coordinate(path->lower_bound_block[4], (float[]){600,90});
+  copy_coordinate(path->upper_bound_block[4], (float[]){720,300});
+  copy_coordinate(path->lower_bound_block[5], (float[]){300,300});
+  copy_coordinate(path->upper_bound_block[5], (float[]){720,350});
+  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
+ 
+
+#else 
+#if 0
+
+
+  copy_coordinate(path->lower_bound_block[4], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[4], (float[]){150,250});
+  copy_coordinate(path->lower_bound_block[3], (float[]){150,40});
+  copy_coordinate(path->upper_bound_block[3], (float[]){250,150});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,80});
+  copy_coordinate(path->upper_bound_block[2], (float[]){360,200});
+  copy_coordinate(path->lower_bound_block[1], (float[]){360,70});
+  copy_coordinate(path->upper_bound_block[1], (float[]){600,150});
+  copy_coordinate(path->lower_bound_block[0], (float[]){600,90});
+  copy_coordinate(path->upper_bound_block[0], (float[]){760,300});
+  copy_coordinate(path->lower_bound_block[6], (float[]){260,300});
+  copy_coordinate(path->upper_bound_block[6], (float[]){760,360});
+  copy_coordinate(path->lower_bound_block[5], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[5], (float[]){410,300});
+
+#else
+#if 0
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[0], (float[]){150,250});
+  copy_coordinate(path->lower_bound_block[1], (float[]){150,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){250,150});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,80});
+  copy_coordinate(path->upper_bound_block[2], (float[]){360,200});
+  copy_coordinate(path->lower_bound_block[3], (float[]){360,70});
+  copy_coordinate(path->upper_bound_block[3], (float[]){600,170});
+  copy_coordinate(path->lower_bound_block[4], (float[]){600,90});
+  copy_coordinate(path->upper_bound_block[4], (float[]){760,300});
+  copy_coordinate(path->lower_bound_block[5], (float[]){300,300});
+  copy_coordinate(path->upper_bound_block[5], (float[]){760,350});
+  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
+
+#else
 #if 1
-TEST(_first_learn_vehicle_50__11){
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[0], (float[]){60,250});
+  copy_coordinate(path->lower_bound_block[1], (float[]){60,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){250,50});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,20});
+  copy_coordinate(path->upper_bound_block[2], (float[]){310,80});
+  copy_coordinate(path->lower_bound_block[3], (float[]){310,40});
+  copy_coordinate(path->upper_bound_block[3], (float[]){450,90});
+  copy_coordinate(path->lower_bound_block[4], (float[]){450,60});
+  copy_coordinate(path->upper_bound_block[4], (float[]){560,220});
+  copy_coordinate(path->lower_bound_block[5], (float[]){430,220});
+  copy_coordinate(path->upper_bound_block[5], (float[]){560,280});
+  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[6], (float[]){430,300});
+
+
+
+#else
+#if 0
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,300});
+  copy_coordinate(path->upper_bound_block[0], (float[]){400,700});
+  copy_coordinate(path->lower_bound_block[1], (float[]){100,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){1000,300});
+  copy_coordinate(path->lower_bound_block[2], (float[]){1000,50});
+  copy_coordinate(path->upper_bound_block[2], (float[]){1400,500});
+  copy_coordinate(path->lower_bound_block[3], (float[]){1400,200});
+  copy_coordinate(path->upper_bound_block[3], (float[]){1800,700});
+  copy_coordinate(path->lower_bound_block[4], (float[]){1100,700});
+  copy_coordinate(path->upper_bound_block[4], (float[]){1700,1000});
+  copy_coordinate(path->lower_bound_block[5], (float[]){800,600});
+  copy_coordinate(path->upper_bound_block[5], (float[]){1100,975});
+  copy_coordinate(path->lower_bound_block[6], (float[]){100,700});
+  copy_coordinate(path->upper_bound_block[6], (float[]){800,975});
+
+#else
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,3});
+  copy_coordinate(path->upper_bound_block[0], (float[]){4,7});
+  copy_coordinate(path->lower_bound_block[1], (float[]){1,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){10,3});
+  copy_coordinate(path->lower_bound_block[2], (float[]){10,0.5});
+  copy_coordinate(path->upper_bound_block[2], (float[]){14,5});
+  copy_coordinate(path->lower_bound_block[3], (float[]){14,2});
+  copy_coordinate(path->upper_bound_block[3], (float[]){18,7});
+  copy_coordinate(path->lower_bound_block[4], (float[]){11,7});
+  copy_coordinate(path->upper_bound_block[4], (float[]){17,10});
+  copy_coordinate(path->lower_bound_block[5], (float[]){8,6});
+  copy_coordinate(path->upper_bound_block[5], (float[]){11,9.75});
+  copy_coordinate(path->lower_bound_block[6], (float[]){1,7});
+  copy_coordinate(path->upper_bound_block[6], (float[]){8,9.75});
+ 
+ 
+#endif
+#endif
+#endif
+#endif
+#endif
+
+  update_bounds_limits_blocks(path);
+
+  struct vehicle *car = create_vehicle(path);
+
+  config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,24,24,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
+  //config_layers *pconf = create_config_layers_from_OneD(3,(size_t[]){3,24,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
+  
+  bool randomize=true; 
+  float minR = -0.5, maxR = 0.5;  
+  //float minR = 0, maxR = 1;  
+  int randomRange = 500;
+  size_t nb_prod_thread = 2;
+  size_t nb_calc_thread = 4;
+  float learning_rate = 0.007 /*0.001*//* 0.0001*/; /* 0.000001*/ /* 0.001*/;  
+  struct networks_qlearning *nnetworks = create_network_qlearning(
+    pconf,
+    randomize, minR, maxR,  randomRange,
+    nb_prod_thread, nb_calc_thread,
+    learning_rate
+  );
+/*
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_20240717_01h42m16s_5300.txt");
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20240717_01h42m16s_5300.txt");
+*/
+  struct main_list_ptr_DIMENSION *m_l_dim=create_var_list_ptr_DIMENSION();
+  //struct main_list_dimension *m_l_dim=create_var_list_dimension();
+
+//EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_TEST__first_learn_vehicle_50__11____9.symlink",m_l_dim);
+ 
+ for(struct list_ptr_DIMENSION *local_l_dim=m_l_dim->begin_list; local_l_dim; local_l_dim=local_l_dim->next){
+   size_t i=local_l_dim->index;
+   char msg[50]; sprintf(msg, " DIM[%ld] ",i);
+   printDebug_dimension((local_l_dim->value), msg);
+ }
+ LOG("%s","=========================================="); 
+  config_layers *base_conf=create_config_layers_from_weight_in_neurons_TYPE_FLOAT(nnetworks->main_net);
+  config_layers *p_conf=create_config_layers_from_m_list_ptr_DIMENSION(m_l_dim);
+  //config_layers *p_conf=create_config_layers_from_m_list_dimension(m_l_dim);
+
+  if(cmp_config_layers(p_conf, base_conf)==0){
+    LOG("base_conf == %s\n","p_conf");
+    
+  }else{
+    LOG("base_conf != %s\n","p_conf");
+
+  }
+LOG("%s ", "base_conf"); print_config_layers(base_conf);
+LOG("%s ", "p_conf"); print_config_layers(p_conf);
+free_config_layers(base_conf);
+free_config_layers(p_conf);
+//free_all_var_list_dimension(m_l_dim);
+///free_all_var_list_ptr_DIMENSION(m_l_dim);
+//remove_all_ptr_type_list_ptr_DIMENSION(m_l_dim);
+purge_ptr_type_list_ptr_DIMENSION(m_l_dim);
+
+//EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20250508_17h50m56s_26300.txt");
+///EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_.symlink");
+///EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_.symlink");
+/*
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_20250508_23h02m40s_29000.txt");
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20250508_23h02m40s_29000.txt");
+*/
+struct status_qlearning *qlstatus = create_status_qlearning ();
+  struct delay_params *dly = create_delay_params (
+    500/*size_t delay_between_episodes*/,
+    50/*size_t delay_between_games*/
+  );
+  
+  struct qlearning_params *qlparams = create_qlearning_params (
+    0.95/*float gamma*/,
+    learning_rate,
+    0 /* (not used!)float discount_factor*/,
+    1.0/*0.99*//*0.0001*//*0.99*/  /*float exploration_factor*/,
+    20/*long int nb_training_before_update_weight_in_target*/,
+    10000/*size_t number_episodes*/
+  );
+/*   UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->main_net, d_f_act , df );
+   UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->main_net, f_act, f );
+   UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->target_net, d_f_act , df );
+   UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->target_net, f_act , f );
+*/
+  qlparams->caller_func_name=malloc(strlen(__func__)+1);
+  strcpy(qlparams->caller_func_name, __func__);
+
+
+  struct print_params *pprint = create_print_params(
+    12/*float scale_x*/,12 /*float scale_y*/,  
+    dly/*struct delay_params * dly_p*/
+  );
+
+  struct RL_agent *rlAgent = create_RL_agent (
+    nnetworks /*struct networks_qlearning * networks*/,
+    car /*struct vehicle *  car*/,
+    qlstatus /*struct status_qlearning * status*/,
+    pprint /*struct print_params * pprint*/,
+    qlparams/*struct qlearning_params *qlearnParams*/
+  );
+
+
+  //learn_to_drive(rlAgent);
+ 	//learn_to_drive(rlAgent);
+  
+	struct arg_bash *bash_arg= create_arg_bash();
+
+  struct arg_run_qlearn_bprint *argQL_BP =   create_arg_run_qlearn_bprint(bash_arg, rlAgent);
+
+  struct arg_var_ * var = create_arg_var_(y_nnn_manager_handle_input, argQL_BP);
+  struct y_socket_t *argS = y_socket_create("1609", 2, 3, var);
+ 
+
+  pthread_t pollTh;
+  pthread_create(&pollTh, NULL, y_socket_poll_fds, (void*)argS);
+
+
+
+
+
+
+
+  pthread_join(pollTh, NULL);
+	//pthread_join(thread_learn, NULL);
+  
+  y_socket_free(argS);
+  free_arg_var_(var);
+  free_arg_run_qlearn_bprint(argQL_BP);
+  //free_RL_agent(rlAgent);
+
+
+
+
+}
+
+
+
+HIDE_TEST(Transfert_learn_mini_learn){
+  size_t nb_block = 7;
+  size_t dim= 2;
+  struct blocks * path = create_blocks(nb_block, dim);
+
+  LOG("debug: f_name = %s\n", __func__);
+
+#if 0
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[0], (float[]){100,250});
+  copy_coordinate(path->lower_bound_block[1], (float[]){100,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){250,80});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,0});
+  copy_coordinate(path->upper_bound_block[2], (float[]){360,140});
+  copy_coordinate(path->lower_bound_block[3], (float[]){360,70});
+  copy_coordinate(path->upper_bound_block[3], (float[]){600,140});
+  copy_coordinate(path->lower_bound_block[4], (float[]){600,90});
+  copy_coordinate(path->upper_bound_block[4], (float[]){720,300});
+  copy_coordinate(path->lower_bound_block[5], (float[]){300,300});
+  copy_coordinate(path->upper_bound_block[5], (float[]){720,350});
+  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
+ 
+#else
+#if 0
+
+
+  copy_coordinate(path->lower_bound_block[4], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[4], (float[]){150,250});
+  copy_coordinate(path->lower_bound_block[3], (float[]){150,40});
+  copy_coordinate(path->upper_bound_block[3], (float[]){250,150});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,80});
+  copy_coordinate(path->upper_bound_block[2], (float[]){360,200});
+  copy_coordinate(path->lower_bound_block[1], (float[]){360,70});
+  copy_coordinate(path->upper_bound_block[1], (float[]){600,150});
+  copy_coordinate(path->lower_bound_block[0], (float[]){600,90});
+  copy_coordinate(path->upper_bound_block[0], (float[]){760,300});
+  copy_coordinate(path->lower_bound_block[6], (float[]){260,300});
+  copy_coordinate(path->upper_bound_block[6], (float[]){760,360});
+  copy_coordinate(path->lower_bound_block[5], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[5], (float[]){410,300});
+
+
+#else
+#if 1
+copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[0], (float[]){150,250});
+  copy_coordinate(path->lower_bound_block[1], (float[]){150,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){250,150});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,80});
+  copy_coordinate(path->upper_bound_block[2], (float[]){360,200});
+  copy_coordinate(path->lower_bound_block[3], (float[]){360,70});
+  copy_coordinate(path->upper_bound_block[3], (float[]){600,170});
+  copy_coordinate(path->lower_bound_block[4], (float[]){600,90});
+  copy_coordinate(path->upper_bound_block[4], (float[]){760,300});
+  copy_coordinate(path->lower_bound_block[5], (float[]){300,300});
+  copy_coordinate(path->upper_bound_block[5], (float[]){760,350});
+  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
+
+#else
+#if 1
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,300});
+  copy_coordinate(path->upper_bound_block[0], (float[]){400,700});
+  copy_coordinate(path->lower_bound_block[1], (float[]){100,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){1000,300});
+  copy_coordinate(path->lower_bound_block[2], (float[]){1000,50});
+  copy_coordinate(path->upper_bound_block[2], (float[]){1400,500});
+  copy_coordinate(path->lower_bound_block[3], (float[]){1400,200});
+  copy_coordinate(path->upper_bound_block[3], (float[]){1800,700});
+  copy_coordinate(path->lower_bound_block[4], (float[]){1100,700});
+  copy_coordinate(path->upper_bound_block[4], (float[]){1700,1000});
+  copy_coordinate(path->lower_bound_block[5], (float[]){800,600});
+  copy_coordinate(path->upper_bound_block[5], (float[]){1100,975});
+  copy_coordinate(path->lower_bound_block[6], (float[]){100,700});
+  copy_coordinate(path->upper_bound_block[6], (float[]){800,975});
+ 
+
+#else 
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,3});
+  copy_coordinate(path->upper_bound_block[0], (float[]){4,7});
+  copy_coordinate(path->lower_bound_block[1], (float[]){1,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){10,3});
+  copy_coordinate(path->lower_bound_block[2], (float[]){10,0.5});
+  copy_coordinate(path->upper_bound_block[2], (float[]){14,5});
+  copy_coordinate(path->lower_bound_block[3], (float[]){14,2});
+  copy_coordinate(path->upper_bound_block[3], (float[]){18,7});
+  copy_coordinate(path->lower_bound_block[4], (float[]){11,7});
+  copy_coordinate(path->upper_bound_block[4], (float[]){17,10});
+  copy_coordinate(path->lower_bound_block[5], (float[]){8,6});
+  copy_coordinate(path->upper_bound_block[5], (float[]){11,9.75});
+  copy_coordinate(path->lower_bound_block[6], (float[]){1,7});
+  copy_coordinate(path->upper_bound_block[6], (float[]){8,9.75});
+ 
+ 
+#endif
+#endif
+#endif
+#endif
+
+  update_bounds_limits_blocks(path);
+
+  struct vehicle *car = create_vehicle(path);
+
+  config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,24,24,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
+  //config_layers *pconf = create_config_layers_from_OneD(3,(size_t[]){3,24,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
+  
+  bool randomize=true; 
+  float minR = -0.5, maxR = 0.5;  
+  //float minR = 0, maxR = 1;  
+  int randomRange = 500;
+  size_t nb_prod_thread = 2;
+  size_t nb_calc_thread = 4;
+  float learning_rate = 0.00001 /*0.001*//* 0.0001*/; /* 0.000001*/ /* 0.001*/;  
+  struct networks_qlearning *nnetworks = create_network_qlearning(
+    pconf,
+    randomize, minR, maxR,  randomRange,
+    nb_prod_thread, nb_calc_thread,
+    learning_rate
+  );
+/*
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_20240717_01h42m16s_5300.txt");
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20240717_01h42m16s_5300.txt");
+*/
+  struct main_list_ptr_DIMENSION *m_l_dim=create_var_list_ptr_DIMENSION();
+  //struct main_list_dimension *m_l_dim=create_var_list_dimension();
+
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_learnDir/.ff_main_TEST_extract_with_pconf____9;1770646800;2400;",m_l_dim);
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_learnDir/.ff_target_TEST_extract_with_pconf____9;1770646800;2400;",m_l_dim);
+ 
+ for(struct list_ptr_DIMENSION *local_l_dim=m_l_dim->begin_list; local_l_dim; local_l_dim=local_l_dim->next){
+   size_t i=local_l_dim->index;
+   char msg[50]; sprintf(msg, " DIM[%ld] ",i);
+   printDebug_dimension((local_l_dim->value), msg);
+ }
+ LOG("%s","=========================================="); 
+  config_layers *base_conf=create_config_layers_from_weight_in_neurons_TYPE_FLOAT(nnetworks->main_net);
+  config_layers *p_conf=create_config_layers_from_m_list_ptr_DIMENSION(m_l_dim);
+  //config_layers *p_conf=create_config_layers_from_m_list_dimension(m_l_dim);
+
+  if(cmp_config_layers(p_conf, base_conf)==0){
+    LOG("base_conf == %s\n","p_conf");
+    
+  }else{
+    LOG("base_conf != %s\n","p_conf");
+
+  }
+LOG("%s ", "base_conf"); print_config_layers(base_conf);
+LOG("%s ", "p_conf"); print_config_layers(p_conf);
+free_config_layers(base_conf);
+free_config_layers(p_conf);
+//free_all_var_list_dimension(m_l_dim);
+///free_all_var_list_ptr_DIMENSION(m_l_dim);
+//remove_all_ptr_type_list_ptr_DIMENSION(m_l_dim);
+purge_ptr_type_list_ptr_DIMENSION(m_l_dim);
+
+//EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20250508_17h50m56s_26300.txt");
+///EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_.symlink");
+///EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_.symlink");
+/*
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_20250508_23h02m40s_29000.txt");
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20250508_23h02m40s_29000.txt");
+*/
+struct status_qlearning *qlstatus = create_status_qlearning ();
+  struct delay_params *dly = create_delay_params (
+    500/*size_t delay_between_episodes*/,
+    50/*size_t delay_between_games*/
+  );
+  
+  struct qlearning_params *qlparams = create_qlearning_params (
+    0.95/*float gamma*/,
+    learning_rate,
+    0 /* (not used!)float discount_factor*/,
+    0.0001/*1.0*//*0.99*//*0.0001*//*0.99*/  /*float exploration_factor*/,
+    20/*long int nb_training_before_update_weight_in_target*/,
+    10000/*size_t number_episodes*/
+  );
+/*   UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->main_net, d_f_act , df );
+   UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->main_net, f_act, f );
+   UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->target_net, d_f_act , df );
+   UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->target_net, f_act , f );
+*/
+  qlparams->caller_func_name=malloc(strlen(__func__)+1);
+  strcpy(qlparams->caller_func_name, __func__);
+
+
+  struct print_params *pprint = create_print_params(
+    12/*float scale_x*/,12 /*float scale_y*/,  
+    dly/*struct delay_params * dly_p*/
+  );
+
+  struct RL_agent *rlAgent = create_RL_agent (
+    nnetworks /*struct networks_qlearning * networks*/,
+    car /*struct vehicle *  car*/,
+    qlstatus /*struct status_qlearning * status*/,
+    pprint /*struct print_params * pprint*/,
+    qlparams/*struct qlearning_params *qlearnParams*/
+  );
+
+
+  //learn_to_drive(rlAgent);
+ 	//learn_to_drive(rlAgent);
+  
+	struct arg_bash *bash_arg= create_arg_bash();
+
+  struct arg_run_qlearn_bprint *argQL_BP =   create_arg_run_qlearn_bprint(bash_arg, rlAgent);
+
+  struct arg_var_ * var = create_arg_var_(y_nnn_manager_handle_input, argQL_BP);
+  struct y_socket_t *argS = y_socket_create("1613", 2, 3, var);
+ 
+
+  pthread_t pollTh;
+  pthread_create(&pollTh, NULL, y_socket_poll_fds, (void*)argS);
+
+
+
+
+
+
+
+  pthread_join(pollTh, NULL);
+	//pthread_join(thread_learn, NULL);
+  
+  y_socket_free(argS);
+  free_arg_var_(var);
+  free_arg_run_qlearn_bprint(argQL_BP);
+  //free_RL_agent(rlAgent);
+
+
+
+
+}
+
+
+
+TEST(transfertlearning_extract_with_pconf){
+  size_t nb_block = 7;
+  size_t dim= 2;
+  struct blocks * path = create_blocks(nb_block, dim);
+
+  LOG("debug: f_name = %s\n", __func__);
+
+#if 0
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[0], (float[]){100,250});
+  copy_coordinate(path->lower_bound_block[1], (float[]){100,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){250,80});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,0});
+  copy_coordinate(path->upper_bound_block[2], (float[]){360,140});
+  copy_coordinate(path->lower_bound_block[3], (float[]){360,70});
+  copy_coordinate(path->upper_bound_block[3], (float[]){600,140});
+  copy_coordinate(path->lower_bound_block[4], (float[]){600,90});
+  copy_coordinate(path->upper_bound_block[4], (float[]){720,300});
+  copy_coordinate(path->lower_bound_block[5], (float[]){300,300});
+  copy_coordinate(path->upper_bound_block[5], (float[]){720,350});
+  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
+ 
+
+#else 
+#if 0
+
+
+  copy_coordinate(path->lower_bound_block[4], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[4], (float[]){150,250});
+  copy_coordinate(path->lower_bound_block[3], (float[]){150,40});
+  copy_coordinate(path->upper_bound_block[3], (float[]){250,150});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,80});
+  copy_coordinate(path->upper_bound_block[2], (float[]){360,200});
+  copy_coordinate(path->lower_bound_block[1], (float[]){360,70});
+  copy_coordinate(path->upper_bound_block[1], (float[]){600,150});
+  copy_coordinate(path->lower_bound_block[0], (float[]){600,90});
+  copy_coordinate(path->upper_bound_block[0], (float[]){760,300});
+  copy_coordinate(path->lower_bound_block[6], (float[]){260,300});
+  copy_coordinate(path->upper_bound_block[6], (float[]){760,360});
+  copy_coordinate(path->lower_bound_block[5], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[5], (float[]){410,300});
+
+#else
+#if 0
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[0], (float[]){150,250});
+  copy_coordinate(path->lower_bound_block[1], (float[]){150,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){250,150});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,80});
+  copy_coordinate(path->upper_bound_block[2], (float[]){360,200});
+  copy_coordinate(path->lower_bound_block[3], (float[]){360,70});
+  copy_coordinate(path->upper_bound_block[3], (float[]){600,170});
+  copy_coordinate(path->lower_bound_block[4], (float[]){600,90});
+  copy_coordinate(path->upper_bound_block[4], (float[]){760,300});
+  copy_coordinate(path->lower_bound_block[5], (float[]){300,300});
+  copy_coordinate(path->upper_bound_block[5], (float[]){760,350});
+  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
+
+#else
+#if 1
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[0], (float[]){60,250});
+  copy_coordinate(path->lower_bound_block[1], (float[]){60,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){250,50});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,20});
+  copy_coordinate(path->upper_bound_block[2], (float[]){310,80});
+  copy_coordinate(path->lower_bound_block[3], (float[]){310,40});
+  copy_coordinate(path->upper_bound_block[3], (float[]){450,90});
+  copy_coordinate(path->lower_bound_block[4], (float[]){450,60});
+  copy_coordinate(path->upper_bound_block[4], (float[]){560,220});
+  copy_coordinate(path->lower_bound_block[5], (float[]){430,220});
+  copy_coordinate(path->upper_bound_block[5], (float[]){560,280});
+  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[6], (float[]){430,300});
+
+
+
+
+#else
+#if 1
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,300});
+  copy_coordinate(path->upper_bound_block[0], (float[]){400,700});
+  copy_coordinate(path->lower_bound_block[1], (float[]){100,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){1000,300});
+  copy_coordinate(path->lower_bound_block[2], (float[]){1000,50});
+  copy_coordinate(path->upper_bound_block[2], (float[]){1400,500});
+  copy_coordinate(path->lower_bound_block[3], (float[]){1400,200});
+  copy_coordinate(path->upper_bound_block[3], (float[]){1800,700});
+  copy_coordinate(path->lower_bound_block[4], (float[]){1100,700});
+  copy_coordinate(path->upper_bound_block[4], (float[]){1700,1000});
+  copy_coordinate(path->lower_bound_block[5], (float[]){800,600});
+  copy_coordinate(path->upper_bound_block[5], (float[]){1100,975});
+  copy_coordinate(path->lower_bound_block[6], (float[]){100,700});
+  copy_coordinate(path->upper_bound_block[6], (float[]){800,975});
+
+#else
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,3});
+  copy_coordinate(path->upper_bound_block[0], (float[]){4,7});
+  copy_coordinate(path->lower_bound_block[1], (float[]){1,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){10,3});
+  copy_coordinate(path->lower_bound_block[2], (float[]){10,0.5});
+  copy_coordinate(path->upper_bound_block[2], (float[]){14,5});
+  copy_coordinate(path->lower_bound_block[3], (float[]){14,2});
+  copy_coordinate(path->upper_bound_block[3], (float[]){18,7});
+  copy_coordinate(path->lower_bound_block[4], (float[]){11,7});
+  copy_coordinate(path->upper_bound_block[4], (float[]){17,10});
+  copy_coordinate(path->lower_bound_block[5], (float[]){8,6});
+  copy_coordinate(path->upper_bound_block[5], (float[]){11,9.75});
+  copy_coordinate(path->lower_bound_block[6], (float[]){1,7});
+  copy_coordinate(path->upper_bound_block[6], (float[]){8,9.75});
+ 
+ 
+#endif
+#endif
+#endif
+#endif
+#endif
+
+  update_bounds_limits_blocks(path);
+
+  struct vehicle *car = create_vehicle(path);
+
+  config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,24,24,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
+  //config_layers *pconf = create_config_layers_from_OneD(3,(size_t[]){3,24,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
+  
+  bool randomize=true; 
+  float minR = -0.5, maxR = 0.5;  
+  //float minR = 0, maxR = 1;  
+  int randomRange = 500;
+  size_t nb_prod_thread = 2;
+  size_t nb_calc_thread = 4;
+  float learning_rate = 0.0001;  // 0.0007 /*0.001*//* 0.0001*/; /* 0.000001*/ /* 0.001*/;  
+  struct networks_qlearning *nnetworks = create_network_qlearning(
+    pconf,
+    randomize, minR, maxR,  randomRange,
+    nb_prod_thread, nb_calc_thread,
+    learning_rate
+  );
+/*
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_20240717_01h42m16s_5300.txt");
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20240717_01h42m16s_5300.txt");
+*/
+  struct main_list_ptr_DIMENSION *m_l_dim=create_var_list_ptr_DIMENSION();
+  //struct main_list_dimension *m_l_dim=create_var_list_dimension();
+
+//EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_learnDir/.ff_main_TEST_extract_with_pconf____9;1770646800;2400;",m_l_dim);
+//EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_learnDir/.ff_target_TEST_extract_with_pconf____9;1770646800;2400;",m_l_dim);
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_learnDir/.ff_main_TEST_extract_with_pconf____9;1770675296;1044700;",m_l_dim);
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_learnDir/.ff_target_TEST_extract_with_pconf____9;1770675296;1044700;",m_l_dim);
+ 
+ for(struct list_ptr_DIMENSION *local_l_dim=m_l_dim->begin_list; local_l_dim; local_l_dim=local_l_dim->next){
+   size_t i=local_l_dim->index;
+   char msg[50]; sprintf(msg, " DIM[%ld] ",i);
+   printDebug_dimension((local_l_dim->value), msg);
+ }
+ LOG("%s","=========================================="); 
+  config_layers *base_conf=create_config_layers_from_weight_in_neurons_TYPE_FLOAT(nnetworks->main_net);
+  config_layers *p_conf=create_config_layers_from_m_list_ptr_DIMENSION(m_l_dim);
+  //config_layers *p_conf=create_config_layers_from_m_list_dimension(m_l_dim);
+
+  if(cmp_config_layers(p_conf, base_conf)==0){
+    LOG("base_conf == %s\n","p_conf");
+    
+  }else{
+    LOG("base_conf != %s\n","p_conf");
+
+  }
+LOG("%s ", "base_conf"); print_config_layers(base_conf);
+LOG("%s ", "p_conf"); print_config_layers(p_conf);
+free_config_layers(base_conf);
+free_config_layers(p_conf);
+//free_all_var_list_dimension(m_l_dim);
+///free_all_var_list_ptr_DIMENSION(m_l_dim);
+//remove_all_ptr_type_list_ptr_DIMENSION(m_l_dim);
+purge_ptr_type_list_ptr_DIMENSION(m_l_dim);
+
+//EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20250508_17h50m56s_26300.txt");
+///EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_.symlink");
+///EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_.symlink");
+/*
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_20250508_23h02m40s_29000.txt");
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20250508_23h02m40s_29000.txt");
+*/
+struct status_qlearning *qlstatus = create_status_qlearning ();
+  struct delay_params *dly = create_delay_params (
+    500/*size_t delay_between_episodes*/,
+    50/*size_t delay_between_games*/
+  );
+  
+  struct qlearning_params *qlparams = create_qlearning_params (
+    0.95/*float gamma*/,
+    learning_rate,
+    0 /* (not used!)float discount_factor*/,
+    0.01/*1.0*//*0.99*//*0.0001*//*0.99*/  /*float exploration_factor*/,
+    20/*long int nb_training_before_update_weight_in_target*/,
+    10000/*size_t number_episodes*/
+  );
+/*   UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->main_net, d_f_act , df );
+   UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->main_net, f_act, f );
+   UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->target_net, d_f_act , df );
+   UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->target_net, f_act , f );
+*/
+  qlparams->caller_func_name=malloc(strlen(__func__)+1);
+  strcpy(qlparams->caller_func_name, __func__);
+
+
+  struct print_params *pprint = create_print_params(
+    12/*float scale_x*/,12 /*float scale_y*/,  
+    dly/*struct delay_params * dly_p*/
+  );
+
+  struct RL_agent *rlAgent = create_RL_agent (
+    nnetworks /*struct networks_qlearning * networks*/,
+    car /*struct vehicle *  car*/,
+    qlstatus /*struct status_qlearning * status*/,
+    pprint /*struct print_params * pprint*/,
+    qlparams/*struct qlearning_params *qlearnParams*/
+  );
+
+
+  //learn_to_drive(rlAgent);
+ 	//learn_to_drive(rlAgent);
+  
+	struct arg_bash *bash_arg= create_arg_bash();
+
+  struct arg_run_qlearn_bprint *argQL_BP =   create_arg_run_qlearn_bprint(bash_arg, rlAgent);
+
+  struct arg_var_ * var = create_arg_var_(y_nnn_manager_handle_input, argQL_BP);
+  struct y_socket_t *argS = y_socket_create("1621", 2, 3, var);
+ 
+
+  pthread_t pollTh;
+  pthread_create(&pollTh, NULL, y_socket_poll_fds, (void*)argS);
+
+
+
+
+
+
+
+  pthread_join(pollTh, NULL);
+	//pthread_join(thread_learn, NULL);
+  
+  y_socket_free(argS);
+  free_arg_var_(var);
+  free_arg_run_qlearn_bprint(argQL_BP);
+  //free_RL_agent(rlAgent);
+
+
+
+
+}
+
+#if 1
+HIDE_TEST(_first_learn_vehicle_50__11){
   size_t nb_block = 7;
   size_t dim= 2;
   struct blocks * path = create_blocks(nb_block, dim);

y_socket_t/include/y_socket_t/y_file_handler.h

@@ -15,6 +15,8 @@
 
 #include "list_t/list_t.h"
 
+extern char sep;
+
 void y_fileNameDateScore(char* filename, char * pre, char* post,size_t score);
 
 struct arg_send_file{

y_socket_t/src/y_socket_t/y_file_handler.c

@@ -80,8 +80,8 @@ int funcCmp_y_ptr_HEADER_T(y_ptr_HEADER_T h1, y_ptr_HEADER_T h2){
 
 int funcCmp_y_ptr_HEADER_T_fn_nameid_mask(y_ptr_HEADER_T h1, y_ptr_HEADER_T h2){
   if(h1==NULL || h2==NULL) return -1;
-  struct main_list_y_ptr_STRING * m_h1_nameid = split_str_to_main_list_y_ptr_STRING(h1->nameid,'_', h1->size_nameid);
-  struct main_list_y_ptr_STRING * m_h2_nameid = split_str_to_main_list_y_ptr_STRING(h2->nameid,'_', h2->size_nameid);
+  struct main_list_y_ptr_STRING * m_h1_nameid = split_str_to_main_list_y_ptr_STRING(h1->nameid,sep, h1->size_nameid);
+  struct main_list_y_ptr_STRING * m_h2_nameid = split_str_to_main_list_y_ptr_STRING(h2->nameid,sep, h2->size_nameid);
 	
 	//int count_match = 0;
 	struct main_list_TYPE_SIZE_T * m_index_not_match = create_var_list_TYPE_SIZE_T();
@@ -459,11 +459,14 @@ int remove_content_from_headers(struct main_list_y_ptr_HEADER_T *m_head_l_t, y_p
   }
 }
 
+char sep='%';
+
 void y_fileNameDateScore(char* filename, char * pre, char* post,size_t score){
  // char *filename=malloc(256);
   time_t t = time(NULL);
-  struct tm tm = *localtime(&t);
-  sprintf(filename,"%s%d%02d%02d_%02dh%02dm%02ds_%ld%s",pre, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,score,post);
+  //struct tm tm = *localtime(&t);
+  //sprintf(filename,"%s%d%02d%02d_%02dh%02dm%02ds_%ld%s",pre, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,score,post);
+  sprintf(filename,"%s%c%ld%c%ld%c%s",pre, sep, t,sep,score,sep,post);
 
   //return filename;
 }
@@ -583,7 +586,7 @@ void* y_socket_send_file_for_node(void* arg){
        set_addr_str_from_node(tempAddr, node);
        c_af=(node).addr.ss_family;
 
-			 sprintf(nameid, "%s_%s_%ld",name_f, tempAddr, timeid);
+			 sprintf(nameid, "%s%c%s%c%ld",name_f,sep, tempAddr,sep, timeid);
 
 for(int tour_i=0;(tour_i<4) && (check_if_in_ok_header_l_(argS->m_ok_head_l_t, nameid) == 0); ++tour_i){
    
@@ -925,7 +928,7 @@ void receve_from_node(struct pollfd *fds, struct main_list_y_ptr_HEADER_T *m_hea
 #if 0
                            size_nameid = sprintf(nameid, "%s_%s_%s_%s",name_f /*filename*/, srcAddr, value_of_(js_dst_v)->type.string, timeid/*value_of_(js_tm_v)->type.string*/);
 #endif
-                           size_nameid = sprintf(nameid, "%s_%s_%s",name_f, srcAddr, /*value_of_(js_dst_v)->type.string,*/ value_of_(js_tm_v)->type.string);
+                           size_nameid = sprintf(nameid, "%s%c%s%c%s",name_f, sep, srcAddr, sep, /*value_of_(js_dst_v)->type.string,*/ value_of_(js_tm_v)->type.string);
                            ///printf("debug: nameid = %s\n", nameid);
 
                            //int intTimeid = atoi(timeid);

y_socket_t/src/y_socket_t/y_list_var_tool.c

@@ -5,6 +5,8 @@ long  long_time_id(){
  // char *filename=malloc(256);
   //char timeid[64];//="20251011215824";
   time_t t = time(NULL);
+  return t;
+#if 0
   struct tm tm = *localtime(&t);
   //sprintf(timeid,"%d%02d%02d%02d%02d%02d", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
 
@@ -13,6 +15,7 @@ long  long_time_id(){
   ///printf("debug: timeid=%s, vs tm=%ld\n",timeid, intm);
   //printf("debug: timeof=%ld, vs tm=%ld, tm_zone=%s\n",tm.tm_gmtoff, long_tm, tm.tm_zone);
   return long_tm;
+#endif
 }
 char * time_id(){
  // char *filename=malloc(256);
@@ -190,6 +193,6 @@ void usage_cmdl(){
   "\t\t\tNeed to add \"seq\" and \"tm\" keys to have good handling, the payload is after the header {}\n"
   "\t\t\tSee y_socket_send_file_for_node function.\n"
   "\t\tpost ok [filenameid]: to acknowledge receipt [filename].\n"
-  "\t\t\t[filenameid] is to precise witch [filename] (file name from whom and when)\n"
+  "\t\t\t[filenameid] is to precise wich [filename] (file name from whom and when)\n"
   );
 }