add functions calculate parallel updates neurons, and debug some leak functions

dimension_t/src/dimension_t/dimension_t.c

@@ -28,6 +28,11 @@ dimension *
 create_dim(size_t sz){
   return CREATE_PERMUTATION_TYPE_SIZE_T(sz);
 }
+
+dimension* clone_dim(dimension *dim){
+  return init_copy_dim(dim->perm,dim->size);
+}
+
 dimension *
 create_reverse_dim(size_t sz){
   dimension *dim = CREATE_PERMUTATION_TYPE_SIZE_T(sz);
@@ -40,6 +45,15 @@ void free_dimension(dimension *d){
   if(d) free_permut_TYPE_SIZE_T(d);
 }
 
+bool is_equal_dim(dimension *d0, dimension *d1){
+  if(d0->size != d1->size) return false;
+  if(d0->rank != d1->rank) return false;
+  for(size_t i=0;i<d0->size; ++i)
+    if(d0->perm[i] != d1->perm[i]) return false;
+
+  return true;
+}
+
 dimension* sub_copy_minus_dim_head(dimension *root, size_t minusSubdim){
   if(minusSubdim < (root->size)){
     dimension *d = INIT_COPY_PERMUTATION_TYPE_SIZE_T(root->perm, (root->size)-minusSubdim);
@@ -160,6 +174,16 @@ void increment_dim_var(dimension *d){
   }
 }
 
+
+void decrement_dim_var(dimension *d){
+  if(endian){
+    (d->perm[0])--;
+  }
+  else{
+    (d->perm[d->size - 1])--;
+  }
+}
+
 void add_dimension(dimension **d, dimension *d0, dimension *d1) {
     (*d) = create_dim(d0->size + d1->size);
     for (size_t i = 0; i < d0->size; i++) (*d)->perm[i] = d0->perm[i];

dimension_t/src/dimension_t/dimension_t.h

@@ -20,8 +20,11 @@ dimension * create_dim(size_t size);
 dimension * create_reverse_dim(size_t size);
 dimension* init_dim(size_t *t, size_t sz);
 dimension* init_copy_dim(size_t *t, size_t sz);
+dimension* clone_dim(dimension *dim);
 void free_dimension(dimension *d);
 
+bool is_equal_dim(dimension *d0, dimension *d1);
+
 dimension* sub_minus_dim_head(dimension *t, size_t minusSubdim);
 dimension* sub_minus_dim_tail(dimension *t, size_t minusSubdim);
 dimension* sub_dim_head(dimension *t, size_t subdim);
@@ -49,6 +52,7 @@ size_t* CoordFromLin(size_t line, dimension *dim);
 void vCoordFromLin(size_t *ret, size_t line, dimension *dim );
 
 void increment_dim_var(dimension *d);
+void decrement_dim_var(dimension *d);
 
 struct list_perm_in_dim{
   size_t index;

neuron_t/src/neuron_t/neuron_t.c

@@ -10,40 +10,71 @@ void calc_net_neurons_##type(neurons_##type *nr){\
   size_t contractNB= ((nr->weight_in)->dim)->size - ((nr->input)->dim)->size ;\
   /*print_tensor_msg_##type((nr->weight_in)," weight_in  calc");*/\
   /*print_tensor_msg_##type((nr->input)," input  calc");*/\
-  nr->TensorContraction(&(nr->net), nr->input, nr->weight_in, contractNB, nr->nb_thread  );\
+  nr->TensorContraction(&(nr->net), nr->input, nr->weight_in, contractNB, nr->nb_prod_thread  );\
   /*print_tensor_msg_##type((nr->net)," net  calc");*/\
 }\
 \
 void calc_out_neurons_##type(neurons_##type *nr){\
   calc_net_neurons_##type(nr);\
-  for(size_t i = 0; i<(nr->net)->dim->rank; ++i){\
+  if(nr->nb_calc_thread <2){\
-    (nr->output)->x[i]=(nr->f_act)((nr->net)->x[i]);\
+    for(size_t i = 0; i<(nr->net)->dim->rank; ++i)\
-  }\
+      (nr->output)->x[i]=(nr->f_act)((nr->net)->x[i]);\
+  }else\
+    update_2tensor_func_##type(nr->output,nr->net,nr->f_act,nr->nb_calc_thread);\
+  /*print_tensor_msg_##type((nr->output)," output calc");\
+  */\
+}\
+type funcalc_delta_target_##type (type net, type target, type output, type(*df1_df_act)(type), type (*df2_dL)(type,type)){\
+  return df1_df_act(net)*df2_dL(target,output);\
+}\
+type funcalc_delta_hidden_out_##type (type net, type temp, type(*df_act)(type)){\
+  return df_act(net)* temp;\
 }\
 void calc_delta_neurons_##type(neurons_##type *nr){\
   if(nr->next_layer == NULL){\
-    for(size_t i = 0; i<(nr->net)->dim->rank; ++i){\
+    if(nr->nb_calc_thread < 2){\
-      (nr->delta_out)->x[i]=(nr->d_f_act)((nr->net)->x[i])*(nr->dL)((nr->target)->x[i],(nr->output)->x[i]);\
+      for(size_t i = 0; i<(nr->net)->dim->rank; ++i)\
+        (nr->delta_out)->x[i]=(nr->d_f_act)((nr->net)->x[i])*(nr->dL)((nr->target)->x[i],(nr->output)->x[i]);\
+      /*print_tensor_msg_##type(nr->delta_out," nr delta_out calc 1 core target delta_out");\
+      */\
+    }else{\
+      update_5tensor_func_##type(nr->delta_out, nr->net, nr->target, nr->output,\
+        funcalc_delta_target_##type , \
+        nr->d_f_act , \
+        nr->dL, \
+        nr->nb_calc_thread);\
+      /*print_tensor_msg_##type(nr->delta_out," nr delta_out calc parallel target delta_out");\
+      */\
     }\
     /*print_tensor_msg_##type(nr->delta_out," nr delta_out  calc delta_out last layer");*/\
   }else{\
-    tensor_##type *temp_w_d;\
+    tensor_##type *temp_w_d=NULL;\
     size_t cntrctnb=(((nr->next_layer)->weight_in)->dim)->size-(((nr->next_layer)->delta_out)->dim)->size ;\
     /*print_tensor_msg_##type((nr->next_layer)->weight_in," nxt weight_in  calc delta_out");*/\
     /*print_tensor_msg_##type((nr->next_layer)->delta_out," nxt delta_out  calc delta_out");*/\
-    nr->TensorContraction(&temp_w_d, ((nr->next_layer)->weight_in), (nr->next_layer)->delta_out,cntrctnb,nr->nb_thread);\
+    nr->TensorContraction(&temp_w_d, ((nr->next_layer)->weight_in), (nr->next_layer)->delta_out,cntrctnb,nr->nb_prod_thread);\
     /*print_tensor_msg_##type(temp_w_d," nxt tmp  calc delta_out");*/\
+    /*decrement_dim_var(temp_w_d->dim);*/\
     \
-    for(size_t i = 0; i<(nr->net)->dim->rank; ++i){\
+    if(nr->nb_calc_thread < 2){\
-      (nr->delta_out)->x[i]=(nr->d_f_act)((nr->net)->x[i]) * temp_w_d->x[i] ;\
+      for(size_t i = 0; i<(nr->net)->dim->rank; ++i)\
+        (nr->delta_out)->x[i]=(nr->d_f_act)((nr->net)->x[i]) * temp_w_d->x[i] ;\
+      /*print_tensor_msg_##type(nr->delta_out," nr delta_out calc 1 core hidden delta_out");\
+     */\
+    }else{\
+      update_4tensor_func_##type(nr->delta_out, nr->net, temp_w_d,\
+        funcalc_delta_hidden_out_##type , \
+        nr->d_f_act , \
+        nr->nb_calc_thread);\
+      /*print_tensor_msg_##type(nr->delta_out," nr delta_out calc parallel hidden delta_out");\
+    */\
     }\
-    /*print_tensor_msg_##type(nr->delta_out," nr delta_out  calc delta_out");*/\
     free_tensor_##type(temp_w_d);\
   }\
 }\
 void update_weight_neurons_##type(neurons_##type *nr){\
-  tensor_##type *tmp_e_w;\
+  tensor_##type *tmp_e_w=NULL;\
-  nr->TensorProduct(&(tmp_e_w), nr->input, nr->delta_out, nr->nb_thread);\
+  nr->TensorProduct(&(tmp_e_w), nr->input, nr->delta_out, nr->nb_prod_thread);\
   /*print_tensor_msg_##type(nr->input," nr input  update wei");*/\
   /*print_tensor_msg_##type(nr->delta_out," nr delta_out  update wei");*/\
   /*print_tensor_msg_##type(tmp_e_w," tmp_e_w  update wei");*/\
@@ -85,7 +116,7 @@ void link_layers_##type(neurons_##type *nPrev, neurons_##type *nNext ){\
 \
 \
 \
-void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **tab_in_layers, size_t *sz_layers, size_t nb_layers){\
+void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **array_dim_in_layers, size_t *sz_layers, size_t nb_layers){\
   neurons_##type *tmp_l=NULL, *ttmp_l=NULL;\
   for(size_t l=0; l<nb_layers; ++l){\
     tmp_l = malloc(sizeof(neurons_##type)); \
@@ -107,7 +138,7 @@ void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **tab_in_
     tmp_l->next_layer = NULL;\
     \
     if(ttmp_l != NULL){\
-      dimension *dim=init_copy_dim(tab_in_layers[l-1],sz_layers[l-1]);\
+      dimension *dim=init_copy_dim(array_dim_in_layers[l-1],sz_layers[l-1]);\
       increment_dim_var(dim);\
       tmp_l->input = CREATE_TENSOR_##type(dim);\
       for(size_t i=0;i<((tmp_l->input)->dim)->rank;++i) (tmp_l->input)->x[i]=(type)l;\
@@ -123,10 +154,12 @@ void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **tab_in_
           dimension *d_w_in;  \
           add_dimension(&d_w_in, (ttmp_l->input)->dim, ((ttmp_l->output)->dim)); \
           ttmp_l->weight_in = CREATE_TENSOR_##type(d_w_in);\
-          init_random_x_##type(ttmp_l->weight_in,0,1,5000);\
+          for(size_t i=0;i<((ttmp_l->weight_in)->dim)->rank;++i) (ttmp_l->weight_in)->x[i]=0.01;\
+          /*init_random_x_##type(ttmp_l->weight_in,0,1,5000);\
+          */\
       }\
       if(l==nb_layers-1) {\
-        dimension *dim_out=init_copy_dim(tab_in_layers[l],sz_layers[l]);\
+        dimension *dim_out=init_copy_dim(array_dim_in_layers[l],sz_layers[l]);\
         tmp_l->output = CREATE_TENSOR_##type(dim_out);\
         for(size_t i=0;i<((tmp_l->output)->dim)->rank;++i) (tmp_l->output)->x[i]=(type)l;\
         tmp_l->target = CREATE_TENSOR_FROM_CPY_DIM_##type(dim_out);\
@@ -138,8 +171,9 @@ void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **tab_in_
         dimension *d_w_in;  \
         add_dimension(&d_w_in, (tmp_l->input)->dim, ((tmp_l->output)->dim)); \
         tmp_l->weight_in = CREATE_TENSOR_##type(d_w_in);\
-        init_random_x_##type(tmp_l->weight_in,0,1,5000);\
+        for(size_t i=0;i<((tmp_l->weight_in)->dim)->rank;++i) (tmp_l->weight_in)->x[i]=0.01;\
-        \
+        /*init_random_x_##type(tmp_l->weight_in,0,1,5000);\
+        */\
       }\
      \
     }\
@@ -151,6 +185,10 @@ void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **tab_in_
   }\
 }\
 \
+void setup_networks_alloutputs_config_##type(neurons_##type **base_nr, config_layers *lconf){\
+  setup_networks_alloutputs_##type(base_nr, lconf->array_dim_in_layers, lconf->sz_layers, lconf->nb_layers);\
+}\
+\
 void setup_all_layers_functions_##type(neurons_##type *base, \
   void (*TensorContraction)(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread),/* nbthread is ignored if not required ! */\
   void (*TensorProduct)(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread),/* nbthread is ignored if not required ! */\
@@ -172,32 +210,34 @@ void setup_all_layers_functions_##type(neurons_##type *base, \
 }\
   \
 void setup_all_layers_params_##type(neurons_##type *base,\
-  size_t nb_thread,\
+  size_t nb_prod_thread,\
+  size_t nb_calc_thread,\
   type learning_rate){\
   \
    neurons_##type *temp = base;\
   while(temp){\
-    temp->nb_thread=nb_thread;\
+    temp->nb_prod_thread=nb_prod_thread;\
+    temp->nb_calc_thread=nb_calc_thread;\
     temp->learning_rate=learning_rate;\
     temp=temp->next_layer;\
   }\
 }\
 \
 \
-void setup_networks_OneD_##type(neurons_##type **base_nr, size_t *tab_in_layers, size_t nb_layers){\
+void setup_networks_OneD_##type(neurons_##type **base_nr, size_t *array_dim_in_layers, size_t nb_layers){\
   size_t *sz_layers=malloc(nb_layers*sizeof(size_t));\
   for(size_t i=0; i<nb_layers;++i) sz_layers[i]=1;\
-  size_t **ttab_in_layers=malloc(nb_layers*sizeof(size_t));\
+  size_t **tarray_dim_in_layers=malloc(nb_layers*sizeof(size_t));\
   for(size_t i=0; i<nb_layers;++i) {\
-    ttab_in_layers[i]=malloc(sizeof(size_t));\
+    tarray_dim_in_layers[i]=malloc(sizeof(size_t));\
-    ttab_in_layers[i][0]=tab_in_layers[i];\
+    tarray_dim_in_layers[i][0]=array_dim_in_layers[i];\
   }\
-  setup_networks_alloutputs_##type(base_nr, ttab_in_layers, sz_layers, nb_layers);\
+  setup_networks_alloutputs_##type(base_nr, tarray_dim_in_layers, sz_layers, nb_layers);\
   \
   for(size_t i=0; i<nb_layers;++i) {\
-    free(ttab_in_layers[i]);\
+    free(tarray_dim_in_layers[i]);\
   }\
-  free(ttab_in_layers);\
+  free(tarray_dim_in_layers);\
   free(sz_layers);\
 }\
 void init_in_out_all_networks_OneD_##type(neurons_##type *nr, type *in, size_t sz_in, type *out, size_t sz_out){\
@@ -213,9 +253,73 @@ void init_in_out_all_networks_OneD_##type(neurons_##type *nr, type *in, size_t s
     }\
   }\
 }\
+void init_copy_in_out_networks_from_tensors_##type(neurons_##type *nr, tensor_##type *input, tensor_##type *target){\
+  if(((nr->output)->dim)->rank == (input->dim)->rank){\
+    for(size_t i=0;i<(input->dim)->rank;++i) (nr->output)->x[i]=input->x[i];\
+  }\
+  neurons_##type *tmp=nr;\
+  while(tmp->next_layer) tmp=tmp->next_layer;\
+  \
+  if(((tmp->target)->dim)->rank == (target->dim)->rank){\
+    for(size_t i=0; i< (target->dim)->rank; ++i) {\
+      (tmp->target)->x[i] = target->x[i]; \
+    }\
+  }\
+}\
+\
+void init_in_out_networks_from_tensors_##type(neurons_##type *nr, tensor_##type *input, tensor_##type *target, neurons_##type *base){\
+  if(is_equal_dim((base->output)->dim , input->dim)){\
+    nr->output = input ;\
+  }\
+  neurons_##type *tmp=nr;\
+  while(tmp->next_layer) tmp=tmp->next_layer;\
+  \
+  if(is_equal_dim((base->target)->dim, target->dim)){\
+      tmp->target = target; \
+  }\
+}\
+neurons_##type * clone_neurons_base_from_input_target_tensors_##type(neurons_##type *base_nr, tensor_##type *input, tensor_##type *target){\
+  neurons_##type *nr = malloc(sizeof(neurons_##type));\
+  neurons_##type *tmpnr = nr, *tmpbs=base_nr, *prevLayer = NULL;\
+  while(tmpbs){\
+    tmpnr->id_layer = tmpbs->id_layer;\
+    tmpnr->nb_prod_thread = tmpbs->nb_prod_thread;\
+    tmpnr->learning_rate = tmpbs->learning_rate;\
+    tmpnr->input  = CLONE_TENSOR_##type(tmpbs->input); \
+    tmpnr->net  = CLONE_TENSOR_##type(tmpbs->net); \
+    tmpnr->weight_in  = CLONE_TENSOR_##type(tmpbs->weight_in); \
+    tmpnr->bias  = CLONE_TENSOR_##type(tmpbs->bias); \
+    tmpnr->weight_out  = CLONE_TENSOR_##type(tmpbs->weight_out); \
+    tmpnr->delta_out  = CLONE_TENSOR_##type(tmpbs->delta_out); \
+    tmpnr->prev_layer = prevLayer;\
+    if(prevLayer)  {\
+      prevLayer->next_layer = tmpnr;\
+      tmpnr->output  = CLONE_TENSOR_##type(tmpbs->output); \
+    }else{\
+      tmpnr->output = NULL;\
+    }\
+    tmpnr->target  = NULL;\
+    prevLayer = tmpnr;\
+    tmpnr->TensorContraction = tmpbs->TensorContraction;\
+    tmpnr->TensorProduct = tmpbs->TensorProduct;\
+    tmpnr->dL = tmpbs->dL;\
+    tmpnr->L = tmpbs->L;\
+    tmpnr->f_act = tmpbs->f_act;\
+    tmpnr->d_f_act = tmpbs->d_f_act;\
+    if(tmpbs->next_layer) tmpnr->next_layer = malloc(sizeof(neurons_##type));\
+    else tmpnr->next_layer =NULL;\
+    tmpbs=tmpbs->next_layer;\
+    tmpnr=tmpnr->next_layer;\
+  }\
+  return nr;\
+}\
+\
 void print_neurons_msg_##type(neurons_##type *nr, char *msg){\
+  char *val=NULL;\
   while(nr){\
-    printf("%s, layer %ld\n",msg,nr->id_layer); \
+    val=type##_TO_STR(nr->learning_rate);\
+    printf("%s, layer %ld nb_prod_thread:%ld nb_calc_thread:%ld, learning_rate:%s\n",msg,nr->id_layer,nr->nb_prod_thread,nr->nb_calc_thread, val); \
+    free(val); val=NULL;\
     PR_LINE;\
     if(nr->input) print_tensor_msg_##type(nr->input," input "); else printf(" input NULL\n");\
     PR_LINE;\
@@ -263,6 +367,75 @@ type error_out_##type(neurons_##type *base){\
   for(size_t i=0; i< ((base->target)->dim)->rank; ++i) sum += base->L((base->target)->x[i], (base->output)->x[i]);\
   return sum / (((base->target)->dim)->rank);\
 }\
+void free_data_set_##type(data_set_##type *ds){\
+  if(ds){\
+    for(size_t i=0;i<ds->size;++i){\
+      free_tensor_##type(ds->input[i]);\
+      free_tensor_##type(ds->target[i]);\
+    }\
+    free(ds->input);\
+    free(ds->target);\
+    free(ds);\
+  }\
+  \
+}\
+data_set_##type * fill_data_set_from_file_##type(char * file_input, size_t pivotSplit){\
+  data_set_##type * ds=malloc(sizeof(data_set_##type));\
+  tensor_##type *input, *target;\
+  parse_file_InputOutput_withDim_to_tensors_##type(&input,&target,file_input,pivotSplit);\
+  ds->size=(input->dim)->perm[0];\
+  ds->input=fromInput_to_array_tensor_##type(input);\
+  ds->target=fromInput_to_array_tensor_##type(target);\
+  free_tensor_##type(input);\
+  free_tensor_##type(target);\
+  return ds;\
+}\
+void print_data_set_msg_##type(data_set_##type *ds, char *msg){\
+  printf("data_set : %s\n",msg);\
+  char mmsg[256];\
+  for(size_t i=0; i<ds->size; ++i){\
+    sprintf(mmsg," (%s) - >input[%ld] ",msg,i);\
+    print_tensor_msg_##type(ds->input[i],mmsg);\
+  }\
+  for(size_t i=0; i<ds->size; ++i){\
+    sprintf(mmsg," (%s) - >target[%ld] ",msg,i);\
+    print_tensor_msg_##type(ds->target[i],mmsg);\
+  }\
+}\
+size_t learning_online_neurons_##type(neurons_##type *base, data_set_##type *dataset, bool (*condition)(type,size_t)){\
+  neurons_##type *tmp=NULL, *ttmp;\
+  size_t nbreps=0;\
+  do{\
+    for(size_t i=0; i<dataset->size; ++i){\
+      init_copy_in_out_networks_from_tensors_##type(base, dataset->input[i],dataset->target[i]);\
+      tmp=base->next_layer;\
+      while(tmp){\
+        calc_out_neurons_##type(tmp);\
+        ttmp = tmp;\
+        tmp = tmp->next_layer;\
+      }\
+      while(ttmp != base){\
+        calc_delta_neurons_##type(ttmp);\
+        update_weight_neurons_##type(ttmp);\
+        ttmp = ttmp->prev_layer;\
+      }\
+    }\
+\
+  }while(!condition(error_out_##type(base), nbreps++));\
+    \
+  \
+  printf(" ### reps : %ld \n",nbreps);\
+  return nbreps;\
+}\
+size_t learning_set_cloneurons_##type(set_cloneurons_##type *clon, data_set_##type *dataset, neurons_##type *base, bool (*condition)(type, size_t)){\
+  size_t nbreps=0;\
+  type err=0;\
+  do{\
+    \
+  }while(!condition(err,nbreps++));\
+  return nbreps;\
+}\
+  
   
   
 GEN_NEURONS_F_(TYPE_FLOAT)

neuron_t/src/neuron_t/neuron_t.h

@@ -2,15 +2,24 @@
 #define __NEURON_T_C__H
 
 #include <stdlib.h>
+#include <pthread.h>
 
 //#include "tools_t/tools_t.h"
 #include "tensor_t/tensor_t.h"
 
+struct config_layers{
+   size_t nb_layers;
+   size_t *sz_layers;
+   size_t **array_dim_in_layers;
+};
+typedef struct config_layers config_layers; 
+
 #define GEN_NEURON_(type)\
 \
 struct neurons_##type {/* layer */\
   size_t id_layer;\
-  size_t nb_thread;\
+  size_t nb_prod_thread;\
+  size_t nb_calc_thread;\
   type learning_rate;\
   tensor_##type *input; \
   tensor_##type *net; /* output tensor_prodContract */\
@@ -35,14 +44,18 @@ struct func_act_##type {\
   type (*func_act)(type x); /* function activation */\
   type (*deriv_func_act)(type x); /* derivate func act */\
 };\
+\
 /*void calc_net_neurons_##type(neurons_##type *nr);*/\
 void calc_out_neurons_##type(neurons_##type *nr);\
 void calc_delta_neurons_##type(neurons_##type *nr);\
 void update_weight_neurons_##type(neurons_##type *nr);\
-/*void setup_networks_##type(neurons_##type **base_nr, size_t **tab_in_layers, size_t *tab_sz_layers, size_t nb_layers);*/\
+/*void setup_networks_##type(neurons_##type **base_nr, size_t **array_dim_in_layers, size_t *tab_sz_layers, size_t nb_layers);*/\
+void init_copy_in_out_networks_from_tensors_##type(neurons_##type *nr, tensor_##type *input, tensor_##type *target);\
+void init_in_out_networks_from_tensors_##type(neurons_##type *nr, tensor_##type *input, tensor_##type *target, neurons_##type *base);\
 void init_in_out_all_networks_##type(neurons_##type *nr, tensor_##type *in, tensor_##type *out);\
-void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **tab_in_layers, size_t *sz_layers, size_t nb_layers);\
+void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **array_dim_in_layers, size_t *sz_layers, size_t nb_layers);\
-void setup_networks_OneD_##type(neurons_##type **base_nr, size_t *tab_in_layers, size_t nb_layers);\
+void setup_networks_alloutputs_config_##type(neurons_##type **base_nr, config_layers *lconf);\
+void setup_networks_OneD_##type(neurons_##type **base_nr, size_t *array_dim_in_layers, size_t nb_layers);\
 void init_in_out_all_networks_OneD_##type(neurons_##type *nr, type *in, size_t sz_in, type *out, size_t sz_out);\
 void print_neurons_msg_##type(neurons_##type *nr, char * msg);\
 \
@@ -57,10 +70,30 @@ void setup_all_layers_functions_##type(neurons_##type *base, \
   type (*d_f_act)(type x)\
 );\
 void setup_all_layers_params_##type(neurons_##type *base,\
-  size_t nb_thread,\
+  size_t nb_prod_thread,\
+  size_t nb_calc_thread,\
   type learning_rate);\
 type error_out_##type(neurons_##type *base);\
-
+struct data_set_##type{\
+  size_t size;\
+  tensor_##type **input;\
+  tensor_##type **target;\
+};\
+typedef struct data_set_##type data_set_##type;\
+void free_data_set_##type(data_set_##type *ds);\
+data_set_##type*  fill_data_set_from_file_##type(char * file_input, size_t pivotSplit);\
+void print_data_set_msg_##type(data_set_##type *ds, char *msg);\
+\
+size_t learning_online_neurons_##type(neurons_##type *base, data_set_##type *dataset, bool (*condition)(type, size_t));\
+\
+struct set_cloneurons_##type{\
+  size_t nb_clone;\
+  config_layers *conf;\
+  neurons_##type *base;\
+  neurons_##type **cloneurons;\
+};\
+typedef struct set_cloneurons_##type set_cloneurons_##type;\
+size_t learning_set_cloneurons_##type(set_cloneurons_##type *clon, data_set_##type *dataset, neurons_##type *base, bool (*condition)(type, size_t));\
 
 GEN_NEURON_(TYPE_FLOAT)
 GEN_NEURON_(TYPE_DOUBLE)

neuron_t/test/Makefile

@@ -14,7 +14,7 @@ NEURODIR=$(PWD)/..
 DIMDIR=$(PWD)/../../dimension_t
 INCLUDE_DIR=$(PWD)/../src
 CFLAGS=-I$(INCLUDE_DIR) -I$(YPERMDIR)/src -I$(YTESTDIR)/include_ytest/include -I$(DIMDIR)/src -I$(TENSDIR)/src #"-D DEBUG=1"
-LDFLAGS=-L$(YTESTDIR) -lytest -lOpenCL -lm
+LDFLAGS=-L$(YTESTDIR) -lytest -lOpenCL -lm -lpthread
 
 #SRC_DIR=$(ROOT_DIR)/src
 #SRC=$(wildcard */*/*.c) 

neuron_t/test/is_good.c

@@ -52,9 +52,9 @@ TEST(init_One){
     f,
     df);
 
-  setup_all_layers_params_TYPE_FLOAT(bn, 2, 0.7);
+  setup_all_layers_params_TYPE_FLOAT(bn, 2, 3, 0.7);
 
-  //print_neurons_msg_TYPE_FLOAT(bn,"bn");
+  print_neurons_msg_TYPE_FLOAT(bn,"bn init");
 
   tmp=bn->next_layer;
   while(tmp){
@@ -71,13 +71,70 @@ TEST(init_One){
   }
 
 
-  print_neurons_msg_TYPE_FLOAT(bn,"bn");
+  print_neurons_msg_TYPE_FLOAT(bn,"bn after ");
 
   LOG(" error : %f\n", error_out_TYPE_FLOAT(bn));
 
   free_neurons_TYPE_FLOAT(bn);
 }
 
+TEST(data_set_from_file){
+  data_set_TYPE_FLOAT *ds= fill_data_set_from_file_TYPE_FLOAT("data.txt",1);
+
+  print_data_set_msg_TYPE_FLOAT(ds,"data");
+
+  free_data_set_TYPE_FLOAT(ds);
+
+}
+
+#define epsilon 0.0001
+
+bool cond(float e, size_t nbreps){
+  //if (nbreps > 5) return true;
+  if ((e<epsilon) && (e>-epsilon)) return true;
+  return false;
+}
+
+TEST(learning_first){
+  
+  data_set_TYPE_FLOAT *ds= fill_data_set_from_file_TYPE_FLOAT("xor.txt",1);
+//  print_data_set_msg_TYPE_FLOAT(ds,"data");
+  neurons_TYPE_FLOAT *bn=NULL, *tmp ;
+  setup_networks_OneD_TYPE_FLOAT(&bn, (size_t[]){2,4,1},3); /* 2 input , 1 target; 1 hidden layer with 5 neurons */
+
+  setup_all_layers_functions_TYPE_FLOAT(bn,
+    tensorContractnProdThread_TYPE_FLOAT,
+    tensorProdThread_TYPE_FLOAT,
+    DL,
+    L,
+    f,
+    df);
+
+  setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 ,  0.5);
+
+
+  size_t reps = learning_online_neurons_TYPE_FLOAT(bn,ds,cond);
+  
+ 
+  char msg[256];
+  for(size_t i=0; i<ds->size; ++i){
+    sprintf(msg, "data set [%ld]",i);
+    init_copy_in_out_networks_from_tensors_TYPE_FLOAT(bn, ds->input[i],ds->target[i]);\
+      tmp=bn->next_layer;\
+      while(tmp){\
+        calc_out_neurons_TYPE_FLOAT(tmp);\
+        tmp = tmp->next_layer;\
+      }
+    print_neurons_msg_TYPE_FLOAT(bn, msg);
+  
+  }
+  
+
+  free_data_set_TYPE_FLOAT(ds);
+  free_neurons_TYPE_FLOAT(bn); 
+
+  LOG("reps = %ld\n",reps);
+}
 
 
 int main(int argc, char **argv){

tensor_t/src/tensor_t/cl_tensor_t.c

@@ -181,7 +181,7 @@
 void cl_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) {  \
     dimension *dd;  \
     add_dimension(&dd, M0->dim, M1->dim); \
-    (*MM)=CREATE_TENSOR_##type(dd);  \
+     _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);  \
     tensor_##type *M = *MM; \
     char *file_cl_src = "../src/kernel_ProdTensor.cl"; \
     char *func_cl_nameEndian = "prodTensorLin_" #type; \
@@ -235,7 +235,7 @@ void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor
     dimension *dd;\
     add_dimension(&dd, dSub0, dSub1);\
     updateRankDim(dd);\
-    *MM = CREATE_TENSOR_##type(dd);\
+     _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
     tensor_##type *M= *MM;\
     char *file_cl_src = "../src/kernel_ProdContractnTensor.cl"; \
     /*char *func_cl_name = "prodContractnTensorLin_" #type;*/ \
@@ -272,7 +272,7 @@ void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor
 void cl2d_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t div0Wsz, size_t div1Wsz) {  \
     dimension *dd;  \
     add_dimension(&dd, M0->dim, M1->dim); \
-    (*MM)=CREATE_TENSOR_##type(dd);  \
+     _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);  \
     tensor_##type *M = *MM; \
     char *file_cl_src = "../src/kernel_2d_ProdTensor.cl"; \
     /*char *func_cl_name = "prodTensor2dLin_" #type;*/ \
@@ -324,7 +324,7 @@ void cl2d_tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tens
     dimension *dd;\
     add_dimension(&dd, dSub0, dSub1);\
     updateRankDim(dd);\
-    *MM = CREATE_TENSOR_##type(dd);\
+     _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
     tensor_##type *M= *MM;\
     char *file_cl_src = "../src/kernel_2d_ProdContractnTensor.cl"; \
     char *func_cl_nameEndian = "prodContractnTensor2dLin_" #type; \

tensor_t/src/tensor_t/tensor_t.c

@@ -61,6 +61,16 @@ long int decr(long int i) { return i - 1; }
     return r_tens;\
   }\
 \
+void _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(tensor_##type **M, dimension *dd){\
+    if(*M){ \
+      if(!is_equal_dim((*M)->dim, dd)){\
+        free_tensor_##type(*M);\
+        (*M)=CREATE_TENSOR_##type(dd);\
+      }else free_dimension(dd); /* because it is not used */\
+    }else{\
+      (*M)=CREATE_TENSOR_##type(dd);\
+    }\
+  }\
 tensor_##type* init_tensor_head_##type(tensor_##type *troot ,dimension *dim){\
     tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
     updateRankDim(dim);\
@@ -107,6 +117,18 @@ tensor_##type* init_copy_tensor_head_##type(tensor_##type *troot ,dimension *dim
     r_tens->x = malloc(sizeof(type)*dim->rank);\
     return r_tens;\
   }\
+\
+tensor_##type* CLONE_TENSOR_##type(tensor_##type *tens){\
+  if(tens){\
+    tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
+    r_tens->dim = clone_dim(tens->dim);\
+    r_tens->x = malloc(sizeof(type) * (tens->dim)->rank);\
+    for(size_t i=0; i<(tens->dim)->rank;++i)\
+      r_tens->x[i]=tens->x[i];\
+    return r_tens;\
+  }\
+  return NULL;\
+}\
 \
   void free_tensor_##type(tensor_##type *  tens){\
     if(tens){\
@@ -486,7 +508,7 @@ void split_copy_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tens
 void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) {  \
   dimension *dd;  \
     add_dimension(&dd, M0->dim, M1->dim); \
-    (*MM)=CREATE_TENSOR_##type(dd);  \
+    _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);  \
   tensor_##type *M = *MM; \
     size_t* coord;  \
     coord = malloc(sizeof(size_t)*(dd->size));  \
@@ -512,7 +534,7 @@ void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ
 void tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) {  \
     dimension *dd;  \
     add_dimension(&dd, M0->dim, M1->dim); \
-    (*MM)=CREATE_TENSOR_##type(dd);  \
+    _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);  \
     tensor_##type *M = *MM; \
     size_t m_idx;\
     for(size_t i=0; i<M0->dim->rank; ++i){\
@@ -567,7 +589,7 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
     add_dimension(&dd, dSub0, dSub1);\
   /*printDebug_dimension(dd,"dd");*/\
     updateRankDim(dd);\
-    *MM = CREATE_TENSOR_##type(dd);\
+    _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
     tensor_##type *M= *MM;\
 \
    \
@@ -625,7 +647,7 @@ void* runProd_thread_##type(void *arg){\
 void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread) {  \
     dimension *dd;  \
     add_dimension(&dd, M0->dim, M1->dim); \
-    (*MM)=CREATE_TENSOR_##type(dd);  \
+    _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);  \
     tensor_##type *M = *MM; \
     \
     \
@@ -687,7 +709,7 @@ void* runProd_thread2d_##type(void *arg){\
 void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread) {  \
     dimension *dd;  \
     add_dimension(&dd, M0->dim, M1->dim); \
-    (*MM)=CREATE_TENSOR_##type(dd);  \
+    _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);  \
     tensor_##type *M = *MM; \
     \
     \
@@ -779,7 +801,7 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
     dimension *dd;\
     add_dimension(&dd, dSub0, dSub1);\
     updateRankDim(dd);\
-    *MM = CREATE_TENSOR_##type(dd);\
+    _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
     tensor_##type *M= *MM;\
 \
 \
@@ -876,7 +898,7 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
     dimension *dd;\
     add_dimension(&dd, dSub0, dSub1);\
     updateRankDim(dd);\
-    *MM = CREATE_TENSOR_##type(dd);\
+    _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
     tensor_##type *M= *MM;\
 \
 \
@@ -942,7 +964,7 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten
     add_dimension(&dd, dSub0, dSub1);\
   /*printDebug_dimension(dd,"dd");*/\
     updateRankDim(dd);\
-    *MM = CREATE_TENSOR_##type(dd);\
+    _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
     tensor_##type *M= *MM;\
 \
     size_t* coord;\
@@ -1202,7 +1224,6 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
       ttmp=ppEnd;\
     }\
     \
-    /*tens = create_tensor_from_list_array_##type(l_a,dim);*/\
     *Tpart1 = create_tensor_from_list_array_##type(l_a1,ddim1);\
     *Tpart2 = create_tensor_from_list_array_##type(l_a2,ddim2);\
     free_array_chainlist_##type(l_a1);\
@@ -1396,7 +1417,7 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
     fclose(f_input);\
 }\
 \
-tensor_##type ** formInput_to_array_tensor_##type(tensor_##type *tens){\
+tensor_##type ** fromInput_to_array_tensor_##type(tensor_##type *tens){\
   tensor_##type **re_tens=malloc((tens->dim)->perm[0]*sizeof(tensor_##type *));\
   dimension *dim=create_dim((tens->dim)->size - 1);\
   for(size_t i=0; i<dim->size; ++i) dim->perm[i]=(tens->dim)->perm[i+1];\
@@ -1498,6 +1519,231 @@ tensor_##type * permute_notOpt_tensor_##type(tensor_##type *org, dimension *dper
   free(coord_tr);\
   return tens_tr;\
 }\
+struct arg_1Update_##type{\
+  type *M0x;\
+  size_t beginRange;\
+  size_t endRange;\
+  type (*func)(type);\
+};\
+void* run1UpdatCalcfunc_thread_##type(void *arg){\
+  struct arg_1Update_##type *arg_t = arg;\
+    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+        arg_t->M0x[i] = arg_t->func(arg_t->M0x[i]);\
+   }\
+}\
+\
+void update_1tensor_func_##type(tensor_##type *M0, type (*func)(type), size_t nbthread){\
+    \
+  pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
+  struct arg_1Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_1Update_##type *));\
+\
+  for(size_t i = 0; i < nbthread; ++i){\
+    arg_th[i]=malloc(sizeof(struct arg_1Update_##type));\
+    arg_th[i]->M0x=M0->x;\
+    arg_th[i]->func=func;\
+    arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
+    arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
+    \
+    pthread_create(&thrd[i], NULL, run1UpdatCalcfunc_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);\
+}  \
+\
+struct arg_2Update_##type{\
+  type *M0x;\
+  type *M1x;\
+  size_t beginRange;\
+  size_t endRange;\
+  type (*func)(type);\
+};\
+void* run2UpdatCalcfunc_thread_##type(void *arg){\
+  struct arg_2Update_##type *arg_t = arg;\
+    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+        arg_t->M0x[i] = arg_t->func(arg_t->M1x[i]);\
+   }\
+}\
+\
+void update_2tensor_func_##type(tensor_##type *M0, tensor_##type *M1, type (*func)(type), size_t nbthread){\
+  if ( is_equal_dim(M0->dim,M1->dim)){ \
+    pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
+    struct arg_2Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_2Update_##type *));\
+  \
+    for(size_t i = 0; i < nbthread; ++i){\
+      arg_th[i]=malloc(sizeof(struct arg_2Update_##type));\
+      arg_th[i]->M0x=M0->x;\
+      arg_th[i]->M1x=M1->x;\
+      arg_th[i]->func=func;\
+      arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
+      arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
+      \
+      pthread_create(&thrd[i], NULL, run2UpdatCalcfunc_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);\
+  }\
+}  \
+\
+struct arg_3Update_##type{\
+  type *M0x;\
+  type *M1x;\
+  type *M2x;\
+  size_t beginRange;\
+  size_t endRange;\
+  type (*func)(type, type);\
+};\
+void* run3UpdatCalcfunc_thread_##type(void *arg){\
+  struct arg_3Update_##type *arg_t = arg;\
+    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+        arg_t->M0x[i] = arg_t->func(arg_t->M1x[i], arg_t->M2x[i]);\
+   }\
+}\
+\
+void update_3tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, type (*func)(type,type), size_t nbthread){\
+  if ( is_equal_dim(M0->dim,M1->dim) && (is_equal_dim(M0->dim, M2->dim))){  \
+    pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
+    struct arg_3Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_3Update_##type *));\
+  \
+    for(size_t i = 0; i < nbthread; ++i){\
+      arg_th[i]=malloc(sizeof(struct arg_3Update_##type));\
+      arg_th[i]->M0x=M0->x;\
+      arg_th[i]->M1x=M1->x;\
+      arg_th[i]->M2x=M2->x;\
+      arg_th[i]->func=func;\
+      arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
+      arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
+      \
+      pthread_create(&thrd[i], NULL, run3UpdatCalcfunc_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);\
+  }\
+}  \
+\
+\
+struct arg_4Update_##type{\
+  type *M0x;\
+  type *M1x;\
+  type *M2x;\
+  size_t beginRange;\
+  size_t endRange;\
+  type (*func)(type, type,  type(*f1)(type));\
+  type(*f1)(type);\
+};\
+void* run4UpdatCalcfunc_thread_##type(void *arg){\
+  struct arg_4Update_##type *arg_t = arg;\
+    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+        arg_t->M0x[i] = arg_t->func(arg_t->M1x[i], arg_t->M2x[i], arg_t->f1);\
+   }\
+}\
+\
+void update_4tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, \
+    type (*func)(type, type,  type(*f1)(type)),\
+    type(*f1)(type),\
+    size_t nbthread){\
+  /*printf(" rankM0=%ld , rank M2:%ld ; iseq :%d \n",(M0->dim)->rank,(M2->dim)->rank,is_equal_dim(M0->dim,M2->dim) );\
+*/\
+   /* printDebug_dimension(M0->dim," dim M0 in update4 ");  \
+    printDebug_dimension(M2->dim," dim M2 in update4 ");  \
+  */if ( is_equal_dim(M0->dim, M1->dim) /*&& (is_equal_dim(M0->dim, M2->dim))*/){  \
+    /*printDebug_dimension(M0->dim," dim M0 in update4 ");  \
+    */pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
+    struct arg_4Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_4Update_##type *));\
+  \
+    for(size_t i = 0; i < nbthread; ++i){\
+      arg_th[i]=malloc(sizeof(struct arg_4Update_##type));\
+      arg_th[i]->M0x=M0->x;\
+      arg_th[i]->M1x=M1->x;\
+      arg_th[i]->M2x=M2->x;\
+      arg_th[i]->func=func;\
+      arg_th[i]->f1=f1;\
+      arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
+      arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
+      \
+      pthread_create(&thrd[i], NULL, run4UpdatCalcfunc_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);\
+  }\
+}  \
+\
+struct arg_5Update_##type{\
+  type *M0x;\
+  type *M1x;\
+  type *M2x;\
+  type *M3x;\
+  size_t beginRange;\
+  size_t endRange;\
+  type (*func)(type, type, type, type(*f1)(type), type (*f2)(type,type) );\
+  type(*f1)(type);\
+  type (*f2)(type,type);\
+};\
+void* run5UpdatCalcfunc_thread_##type(void *arg){\
+  struct arg_5Update_##type *arg_t = arg;\
+    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+        arg_t->M0x[i] = arg_t->func(arg_t->M1x[i], arg_t->M2x[i], arg_t->M3x[i], arg_t->f1, arg_t->f2);\
+   }\
+}\
+\
+void update_5tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, tensor_##type *M3 , \
+    type (*func) (type, type, type, type(*f1)(type), type (*f2)(type,type)), \
+    type(*f1)(type), \
+    type (*f2)(type,type), \
+    size_t nbthread){\
+  if ( is_equal_dim(M0->dim,M1->dim) && (is_equal_dim(M0->dim, M2->dim))&& (is_equal_dim(M0->dim, M3->dim))){  \
+    pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
+    struct arg_5Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_5Update_##type *));\
+    /*printDebug_dimension(M0->dim," dim M0 in update5 "); */ \
+    for(size_t i = 0; i < nbthread; ++i){\
+      arg_th[i]=malloc(sizeof(struct arg_5Update_##type));\
+      arg_th[i]->M0x=M0->x;\
+      arg_th[i]->M1x=M1->x;\
+      arg_th[i]->M2x=M2->x;\
+      arg_th[i]->M3x=M3->x;\
+      arg_th[i]->func=func;\
+      arg_th[i]->f1=f1;\
+      arg_th[i]->f2=f2;\
+      arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
+      arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
+      \
+      pthread_create(&thrd[i], NULL, run5UpdatCalcfunc_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);\
+  }\
+}  \
+\
+
 
 
 GEN_FUNC_TENSOR(TYPE_FLOAT);

tensor_t/src/tensor_t/tensor_t.h

@@ -17,6 +17,8 @@ struct tensor_##type{\
 typedef struct tensor_##type tensor_##type;\
 tensor_##type * CREATE_TENSOR_##type(dimension *dim); \
 tensor_##type* CREATE_TENSOR_FROM_CPY_DIM_##type(dimension *dim);\
+void _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(tensor_##type **M, dimension *dd);\
+tensor_##type* CLONE_TENSOR_##type(tensor_##type *tens);\
 void free_tensor_##type(tensor_##type *  tens); \
 tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
 tensor_##type * sub_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
@@ -42,7 +44,7 @@ void init_random_x_##type(tensor_##type *M, type minR, type maxR,  int randomRan
 tensor_##type * parseInput_withDim_to_tensor_##type(char *input);\
 void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *input, size_t pivotSplit);\
 void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *file_name_input, size_t pivotSplit);\
-tensor_##type ** formInput_to_array_tensor_##type(tensor_##type *tens);\
+tensor_##type ** fromInput_to_array_tensor_##type(tensor_##type *tens);\
 struct array_chainlist_##type{\
   size_t index;\
   type x;\
@@ -54,6 +56,22 @@ tensor_##type * create_tensor_from_list_array_##type( array_chainlist_##type *l_
 void free_array_chainlist_##type(array_chainlist_##type *l_a);\
 tensor_##type * transpose_notOpt_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);\
+void update_2tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \
+    type (*func)(type), size_t nbthread);\
+void update_3tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, \
+    type (*func)(type, type), size_t nbthread);\
+void update_4tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, \
+    type (*func)(type, type,  type(*f1)(type)),\
+    type(*f1)(type),\
+    size_t nbthread);\
+void update_5tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, tensor_##type *M3 , \
+    type (*func) (type, type, type, type(*f1)(type), type (*f2)(type,type)), \
+    type(*f1)(type), \
+    type (*f2)(type,type), \
+    size_t nbthread);\
+
 
 
 GENERATE_TENSOR_TYPE(TYPE_FLOAT);

tensor_t/test/is_good.c

@@ -544,8 +544,8 @@ TEST(tensorProd ){
   print_tensor_float(M1,"M1");
 
 
-  tensor_TYPE_FLOAT *M; 
+  tensor_TYPE_FLOAT *M=NULL; 
-  tensor_TYPE_FLOAT *Mn; 
+  tensor_TYPE_FLOAT *Mn=NULL; 
 
   tensorProd_TYPE_FLOAT(&M,M0,M1);
   tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
@@ -603,8 +603,8 @@ TEST(tensorContractnProd_TYPE_FLOAT ){
   print_tensor_float(M0,"M0");
   print_tensor_float(M1,"M1");
 
-  tensor_TYPE_FLOAT *M;
+  tensor_TYPE_FLOAT *M=NULL;
-  tensor_TYPE_FLOAT *MnO;
+  tensor_TYPE_FLOAT *MnO=NULL;
 
   tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
   tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
@@ -664,8 +664,8 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
 //  print_tensor_float(M0,"M0");
 //  print_tensor_float(M1,"M1");
 
-  tensor_TYPE_FLOAT *M;
+  tensor_TYPE_FLOAT *M=NULL;
-  tensor_TYPE_FLOAT *MnO;
+  tensor_TYPE_FLOAT *MnO=NULL;
 
   tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
 //  print_tensor_float(M,"M");
@@ -717,8 +717,8 @@ TEST(tensorContractnProd_TYPE_DOUBLE_2_1 ){
   print_tensor_double(M0,"M0");
   print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,1);
   //print_tensor_double(M,"M");
@@ -774,8 +774,8 @@ TEST(tensorContractnProd_TYPE_DOUBLE_2_2 ){
   print_tensor_double(M0,"M0");
   print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,1);
   //print_tensor_double(M,"M");
@@ -836,8 +836,8 @@ TEST(tensorContractnProd_TYPE_DOUBLE2 ){
   //print_tensor_double(M0,"M0");
   //print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
   //print_tensor_double(M,"M");
@@ -897,8 +897,8 @@ TEST(VStensorContractnProd_TYPE_DOUBLE2 ){
   //print_tensor_double(M0,"M0");
   //print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
   //print_tensor_double(M,"M");
@@ -959,8 +959,8 @@ TEST(Pthread_tensorContractnPro2d_TYPE_DOUBLE2 ){
   //print_tensor_double(M0,"M0");
   //print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   size_t nbthread = 5;
 
@@ -1017,8 +1017,8 @@ TEST(contract_dim1){
   print_tensor_double(M0,"M0");
   print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   size_t nbthread = 5;
 
@@ -1085,8 +1085,8 @@ TEST(Pthread_tensorContractnProd_TYPE_DOUBLE2 ){
   //print_tensor_double(M0,"M0");
   //print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   size_t nbthread = 5;
 
@@ -1146,8 +1146,8 @@ TEST(tensorProd_vs ){
   for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
 
 
-  tensor_TYPE_FLOAT *M; 
+  tensor_TYPE_FLOAT *M=NULL; 
-  tensor_TYPE_FLOAT *Mn; 
+  tensor_TYPE_FLOAT *Mn=NULL; 
 
   tensorProd_TYPE_FLOAT(&M,M0,M1);
   //tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
@@ -1201,8 +1201,8 @@ TEST(tensorProd_vsThread ){
 
 
 
-  tensor_TYPE_FLOAT *M; 
+  tensor_TYPE_FLOAT *M=NULL; 
-  tensor_TYPE_FLOAT *Mn; 
+  tensor_TYPE_FLOAT *Mn=NULL; 
 
   size_t nbthread = 5;
 
@@ -1258,8 +1258,8 @@ TEST(tensorProd_vsThread2d ){
   for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
 
 
-  tensor_TYPE_FLOAT *M; 
+  tensor_TYPE_FLOAT *M=NULL; 
-  tensor_TYPE_FLOAT *Mn; 
+  tensor_TYPE_FLOAT *Mn=NULL; 
 
   size_t nbthread = 5;
 
@@ -1379,7 +1379,7 @@ TEST(parseInputOutput_unknownpart_to_tensor){
                "((0,0,0,1,2)"\
                "(0,0,0,2,4)) ";
 
-  tensor_TYPE_FLOAT *t0,*t1;
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
   parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
 
   print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1401,7 +1401,7 @@ TEST(parseInputOutput_knownpart_to_tensor){
                "((0,0,0,1,2)"\
                "(0,0,0,2,4)) ";
 
-  tensor_TYPE_FLOAT *t0,*t1;
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
   parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
 
   print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1423,7 +1423,7 @@ TEST(parseInputOutput_unknownpart2dimInput_to_tensor){
                "((0,0,0),(8,8,8),1,2)"\
                "(0,0,0),(8,8,8),2,4)) ";
 
-  tensor_TYPE_FLOAT *t0,*t1;
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
   parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
 
   print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1445,7 +1445,7 @@ TEST(parseInputOutput_knownpart2dimInput_to_tensor){
                "((0,0,0),(8,8,8),1,2)"\
                "(0,0,0),(8,8,8),2,4)) ";
 
-  tensor_TYPE_FLOAT *t0,*t1;
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
   parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
 
   print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1468,7 +1468,7 @@ TEST(parseInputOutput_unknownpart1dimInput_2output_to_tensor){
                "((0,0,0),(8,8,8)8,1,2)"\
                "(0,0,0),(8,8,8)8,2,4)) ";
 
-  tensor_TYPE_FLOAT *t0,*t1;
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
   parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 2);
 
   print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1491,7 +1491,7 @@ TEST(parseInputOutput_knownpart1dimInput_2output_to_tensor){
                "((0,0,0),(8,8,8)8,1,2)"\
                "(0,0,0),(8,8,8)8,2,4)) ";
 
-  tensor_TYPE_FLOAT *t0,*t1;
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
   parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 2);
 
   print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1514,7 +1514,7 @@ TEST(parseInputOutput_unknownpart1dimInput_1output_to_tensor){
                "((0,0,0),(8,8,8)8,1,2)"\
                "(0,0,0),(8,8,8)8,2,4)) ";
 
-  tensor_TYPE_FLOAT *t0,*t1;
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
   parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
 
   print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1537,7 +1537,7 @@ TEST(parseInputOutput_knownpart1dimInput_1output_to_tensor){
                "((0,0,0),(8,8,8)8,1,5)"\
                "(0,0,0),(8,8,8)8,2,4)) ";
 
-  tensor_TYPE_FLOAT *t0,*t1;
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
   parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
 
   print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1553,7 +1553,7 @@ TEST(parseInputOutput_file_knownpart1dimInput_1output_to_tensor){
   endian=true;
   char *inputfile="input.txt";
 
-  tensor_TYPE_FLOAT *t0,*t1;
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
   parse_file_InputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , inputfile, 1);
 
   print_tensor_msg_TYPE_FLOAT(t0," t0 from inputfile" );
@@ -1571,7 +1571,7 @@ TEST(parseInputOutput_file_knownpart1dimInput_1output_to_tensor){
   endian=true;
   char *inputfile="unkinput.txt";
 
-  tensor_TYPE_FLOAT *t0,*t1;
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
   parse_file_InputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , inputfile, 1);
 
   print_tensor_msg_TYPE_FLOAT(t0," t0 from inputfile" );
@@ -1589,14 +1589,14 @@ TEST(array_from_parseInputOutput_file_knownpart1dimInput_1output_to_tensor){
   endian=true;
   char *inputfile="unkinput.txt";
 
-  tensor_TYPE_FLOAT *t0,*t1;
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
   parse_file_InputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , inputfile, 1);
 
   print_tensor_msg_TYPE_FLOAT(t0," t0 from inputfile" );
   print_tensor_msg_TYPE_FLOAT(t1," t1 from inputfile" );
 
-  tensor_TYPE_FLOAT **arrt0 =  formInput_to_array_tensor_TYPE_FLOAT(t0);
+  tensor_TYPE_FLOAT **arrt0 =  fromInput_to_array_tensor_TYPE_FLOAT(t0);
-  tensor_TYPE_FLOAT **arrt1 =  formInput_to_array_tensor_TYPE_FLOAT(t1);
+  tensor_TYPE_FLOAT **arrt1 =  fromInput_to_array_tensor_TYPE_FLOAT(t1);
 
 
   size_t sz0=(t0->dim)->perm[0];
@@ -1622,8 +1622,33 @@ TEST(array_from_parseInputOutput_file_knownpart1dimInput_1output_to_tensor){
   free_tensor_TYPE_FLOAT(t1);
 }
 
+float func2(float x){
+  return x*x+1;
+}
+
+TEST(update_func_){
+  dimension *d0=create_dim(3);
+
+  d0->perm[0]=2;
+  d0->perm[1]=3;
+  d0->perm[2]=4;
 
 
+  updateRankDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+
+  init_random_x_TYPE_FLOAT(M0,2.7,5.4,50001);
+
+  print_tensor_float(M0, "init M0 random");
+  
+  update_1tensor_func_TYPE_FLOAT(M0, func2, 5); 
+
+  print_tensor_float(M0, "x*x+1 M0 random");
+}
 
 
 

tensor_t/test_cl/is_good.c

@@ -86,8 +86,8 @@ TEST(tensorProd ){
   print_tensor_float(M1,"M1");
 
 
-  tensor_TYPE_FLOAT *M; 
+  tensor_TYPE_FLOAT *M=NULL; 
-  tensor_TYPE_FLOAT *Mn; 
+  tensor_TYPE_FLOAT *Mn=NULL; 
 
   tensorProd_TYPE_FLOAT(&M,M0,M1);
   tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
@@ -131,8 +131,8 @@ TEST(tensorContractnProd_TYPE_FLOAT ){
   print_tensor_float(M0,"M0");
   print_tensor_float(M1,"M1");
 
-  tensor_TYPE_FLOAT *M;
+  tensor_TYPE_FLOAT *M=NULL;
-  tensor_TYPE_FLOAT *MnO;
+  tensor_TYPE_FLOAT *MnO=NULL;
 
   tensorContractnProd_TYPE_FLOAT(&M, M0,M1,1);
   tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,1);
@@ -180,8 +180,8 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
 //  print_tensor_float(M0,"M0");
 //  print_tensor_float(M1,"M1");
 
-  tensor_TYPE_FLOAT *M;
+  tensor_TYPE_FLOAT *M=NULL;
-  tensor_TYPE_FLOAT *MnO;
+  tensor_TYPE_FLOAT *MnO=NULL;
 
   tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
 //  print_tensor_float(M,"M");
@@ -231,8 +231,8 @@ TEST(cl_tensorContractnProd_TYPE_FLOAT2 ){
 //  print_tensor_float(M0,"M0");
 //  print_tensor_float(M1,"M1");
 
-  tensor_TYPE_FLOAT *M;
+  tensor_TYPE_FLOAT *M=NULL;
-  tensor_TYPE_FLOAT *MnO;
+  tensor_TYPE_FLOAT *MnO=NULL;
 
   tensorContractnProdNotOpt_TYPE_FLOAT(&M, M0,M1,2);
 //  print_tensor_float(M,"M");
@@ -280,8 +280,8 @@ TEST(cl_tensorContractnProd_TYPE_DOUBLE2 ){
   //print_tensor_double(M0,"M0");
   //print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2);
   //tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
@@ -341,8 +341,8 @@ TEST(tensorContractnProd_TYPE_DOUBLE2 ){
   //print_tensor_double(M0,"M0");
   //print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
   //print_tensor_double(M,"M");
@@ -392,8 +392,8 @@ TEST(TensorProdCL){
 
 
 
-  tensor_TYPE_FLOAT *M; 
+  tensor_TYPE_FLOAT *M=NULL; 
-  tensor_TYPE_FLOAT *Mn; 
+  tensor_TYPE_FLOAT *Mn=NULL; 
 
   tensorProd_TYPE_FLOAT(&M,M0,M1);
   cl_tensorProd_TYPE_FLOAT(&Mn,M0,M1);
@@ -452,8 +452,8 @@ TEST(VS_thrd_tensorContractnProd_TYPE_DOUBLE2 ){
   //print_tensor_double(M0,"M0");
   //print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   size_t nbth=10;
 
@@ -523,8 +523,8 @@ TEST(VS_thrd_tensorContractnProd_TYPE_DOUBLE2 ){
   //print_tensor_double(M0,"M0");
   //print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   size_t nbth=15;
 
@@ -598,8 +598,8 @@ TEST(VS_thrd_tensorContractnProd_TYPE_DOUBLE2 ){
   //print_tensor_double(M0,"M0");
   //print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   size_t nbth=10;
 
@@ -675,8 +675,8 @@ TEST(VScltensorContractnProd_TYPE_DOUBLE2 ){
   //print_tensor_double(M0,"M0");
   //print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   size_t nbth = 10;
 
@@ -741,8 +741,8 @@ TEST(VScl2dtensorContractnProd_TYPE_DOUBLE2 ){
   //print_tensor_double(M0,"M0");
   //print_tensor_double(M1,"M1");
 
-  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *M=NULL;
-  tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO=NULL;
 
   size_t nbth = 10;
 
@@ -799,8 +799,8 @@ TEST(tensorProd_vs2d ){
   print_tensor_float(M1,"M1");*/
 
 
-  tensor_TYPE_FLOAT *M;
+  tensor_TYPE_FLOAT *M=NULL;
-  tensor_TYPE_FLOAT *Mn;
+  tensor_TYPE_FLOAT *Mn=NULL;
 
   cl_tensorProd_TYPE_FLOAT(&M,M0,M1);
   tensorProd_TYPE_FLOAT(&Mn,M0,M1);
@@ -847,8 +847,8 @@ TEST(tensorProd_vs2d ){
   print_tensor_float(M1,"M1");*/
 
 
-  tensor_TYPE_FLOAT *M;
+  tensor_TYPE_FLOAT *M=NULL;
-  tensor_TYPE_FLOAT *Mn;
+  tensor_TYPE_FLOAT *Mn=NULL;
 
   tensorProd_TYPE_FLOAT(&M,M0,M1);
   //cl2d_tensorProd_TYPE_FLOAT(&Mn,M0,M1,24,24);
@@ -896,8 +896,8 @@ TEST(tensorProd_vs2d_Endian ){
   print_tensor_float(M1,"M1");*/
 
 
-  tensor_TYPE_FLOAT *M;
+  tensor_TYPE_FLOAT *M=NULL;
-  tensor_TYPE_FLOAT *Mn;
+  tensor_TYPE_FLOAT *Mn=NULL;
 
   cl_tensorProd_TYPE_FLOAT(&M,M0,M1);
   tensorProd_TYPE_FLOAT(&Mn,M0,M1);
@@ -942,8 +942,8 @@ TEST(tensorProd_vs2d_Endian ){
 
 
 
-  tensor_TYPE_FLOAT *M;
+  tensor_TYPE_FLOAT *M=NULL;
-  tensor_TYPE_FLOAT *Mn;
+  tensor_TYPE_FLOAT *Mn=NULL;
 
   tensorProd_TYPE_FLOAT(&M,M0,M1);
   //cl2d_tensorProd_TYPE_FLOAT(&Mn,M0,M1,24,24);