From bce05df0aee1b192233770181b561c4761e83ff2 Mon Sep 17 00:00:00 2001
From: fanasina <rafanasin@gmail.com>
Date: Sat, 4 Apr 2026 00:43:28 +0200
Subject: [PATCH] [init]: init tensor repo one file header

---
 .gitignore                 |   2 +
 linktest/y_test_h.h        |   1 +
 list_t/Makefile            |  56 +++
 list_t/list_t.h            | 438 ++++++++++++++++++++
 list_t/src/list_t/list_t.c | 155 ++++++++
 list_t/src/list_t/list_t.h | 478 ++++++++++++++++++++++
 list_t/src/list_t/list_t.o | Bin 0 -> 101768 bytes
 list_t/test/Makefile       |  60 +++
 list_t/test/compile.sh     |  23 ++
 onetensor/testDimension.c  | 271 +++++++++++++
 onetensor/y_tensor_h.h     | 789 +++++++++++++++++++++++++++++++++++++
 11 files changed, 2273 insertions(+)
 create mode 100644 .gitignore
 create mode 120000 linktest/y_test_h.h
 create mode 100644 list_t/Makefile
 create mode 100644 list_t/list_t.h
 create mode 100755 list_t/src/list_t/list_t.c
 create mode 100644 list_t/src/list_t/list_t.h
 create mode 100644 list_t/src/list_t/list_t.o
 create mode 100644 list_t/test/Makefile
 create mode 100755 list_t/test/compile.sh
 create mode 100644 onetensor/testDimension.c
 create mode 100644 onetensor/y_tensor_h.h

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..795c8e4
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+**.swp
+**is_good*
diff --git a/linktest/y_test_h.h b/linktest/y_test_h.h
new file mode 120000
index 0000000..436f44c
--- /dev/null
+++ b/linktest/y_test_h.h
@@ -0,0 +1 @@
+../../onefileheader_test/y_test_h.h
\ No newline at end of file
diff --git a/list_t/Makefile b/list_t/Makefile
new file mode 100644
index 0000000..f9c3d8c
--- /dev/null
+++ b/list_t/Makefile
@@ -0,0 +1,56 @@
+# file list_t/Makefile
+CC=gcc
+ROOTPROJECTDIR:=$(realpath ..)
+TOOLDIR=$(ROOTPROJECTDIR)/ytools_t
+
+INCLUDE_DIR=$(TOOLDIR)/include
+CFLAGS=-I$(INCLUDE_DIR) -I./src 
+
+#SRC_DIR=$(ROOT_DIR)/src
+#SRC=$(wildcard */*/*.c) 
+#HEADS=$(OBJS:.o=.h)
+
+LISTSRC=src/list_t/list_t.c
+LISTSRC_O=$(LISTSRC:.c=.o)
+
+SETTSRC=src/set_theoric_t/set_theoric_t.c
+SETTSRC_O=$(SETTSRC:.c=.o)
+
+
+TOOLSRC_O=$(TOOLDIR)/src/tools_t/tools_t.o
+#TOOLSRC=$(TOOLDIR)/src/tools_t/tools_t.c
+#TOOLSRC_O=$(TOOLSRC:.c=.o)
+
+SRC=$(wildcard **/**/*.c) 
+OBJ=$(SRC:.c=.o) #$(TOOLSRC_O) 
+
+TOPTARGETS := all clean
+DEP=$(TOOLDIR)
+
+$(TOPTARGETS): $(DEP)
+
+all: $(LISTSRC_O)
+
+
+$(LISTSRC_O): $(LISTSRC) $(TOOLSRC_O)
+	$(CC) -o $@ -c $< $(CFLAGS)
+
+#$(SETTSRC_O) : $(SETTSRC) $(TOOLSRC_O)
+#	$(CC) -o $@ -c $< $(CFLAGS)
+
+$(DEP):
+	$(MAKE) -C $@ $(MAKECMDGOALS)
+
+#$(TOOLSRC_O): $(TOOLSRC) 
+#	$(CC) -o $@ -c $< $(CFLAGS)
+
+.PHONY: clean mrproper
+
+clean:
+	rm -f $(OBJ)
+
+mrproper: clean
+	rm -f $(EXEC)
+
+run: $(EXEC)
+	$(EXEC) -h
diff --git a/list_t/list_t.h b/list_t/list_t.h
new file mode 100644
index 0000000..5418ccf
--- /dev/null
+++ b/list_t/list_t.h
@@ -0,0 +1,438 @@
+#ifndef __LIST_T_H__
+#define __LIST_T_H__
+
+#include <omp.h>
+
+//#include <pthread.h>
+
+
+#define TYPE_PTR void*
+
+#define CREATE_HEADER_LIST(type)\
+  struct list_##type {\
+    type value;\
+    size_t index;\
+    struct list_##type *preview;\
+    struct list_##type *next;\
+  };\
+  struct main_list_##type {\
+    struct list_##type *begin_list;\
+    struct list_##type *current_list;\
+    size_t current_index;\
+    struct list_##type *end_list;\
+    size_t size;\
+  };\
+  struct main_list_##type *create_var_list_##type();\
+  void push_back_list_##type(struct main_list_##type *var_list, type value);\
+  void push_front_list_##type(struct main_list_##type *var_list, type value);\
+  size_t move_current_to_index_list_##type(struct main_list_##type *var_list, size_t index, struct list_##type **list_in_index);\
+  size_t move_current_to_begin_list_##type(struct main_list_##type *var_list);\
+  size_t move_current_to_end_list_##type(struct main_list_##type *var_list);\
+  size_t insert_into_list_##type(struct main_list_##type *var_list, size_t index, type value );\
+  void remove_index_from_list_##type(struct main_list_##type *var_list, size_t index );\
+  struct list_##type* pull_index_from_list_##type(struct main_list_##type *var_list, size_t index );\
+  void free_all_var_list_##type(struct main_list_##type *var_list);\
+  void remove_all_list_in_##type(struct main_list_##type *var_list);\
+  void increment_list_##type(struct main_list_##type * var_list);\
+  void decrement_list_##type(struct main_list_##type * var_list);\
+  struct list_##type * search_first_occ_with_mov_from_curr_in_list_##type(struct main_list_##type *var_list, \
+    type value, int (*funcCmp)(type, type), struct list_##type * (*incr_or_decr_mov)(struct list_##type *));\
+  struct list_##type * search_first_occ_from_begin_in_list_##type(struct main_list_##type *var_list, type value, int (*funcCmp)(type, type));\
+  struct list_##type * search_first_occ_from_end_in_list_##type(struct main_list_##type *var_list, type value, int (*funcCmp)(type, type));\
+  struct list_##type * pull_end_from_list_##type(struct main_list_##type *var_list);\
+  struct list_##type * pull_begin_from_list_##type(struct main_list_##type *var_list);\
+  void append_list_##type(struct main_list_##type *var_list, struct list_##type *list);\
+  struct list_##type * local_increment_list_##type(struct list_##type *list);\
+  struct list_##type * local_decrement_list_##type(struct list_##type *list);\
+ 
+
+#if 0
+
+GENERATE_LIST_ALL(TYPE_CHAR)
+GENERATE_LIST_ALL(TYPE_U_CHAR)
+GENERATE_LIST_ALL(TYPE_INT)
+GENERATE_LIST_ALL(TYPE_U_INT)
+GENERATE_LIST_ALL(TYPE_L_INT)
+GENERATE_LIST_ALL(TYPE_U_L_INT)
+GENERATE_LIST_ALL(TYPE_SIZE_T)
+GENERATE_LIST_ALL(TYPE_FLOAT)
+GENERATE_LIST_ALL(TYPE_DOUBLE)
+GENERATE_LIST_ALL(TYPE_L_DOUBLE)
+GENERATE_LIST_ALL(TYPE_STRING)
+
+GENERATE_LIST_ALL(TYPE_PTR)
+
+#endif
+
+#define FOR_LIST_FORM_BEGIN(type, var_list)\
+  for(move_current_to_begin_list_##type(var_list); var_list->current_list; increment_list_##type(var_list))
+
+#define FOR_LIST_FORM_END(type, var_list)\
+  for(move_current_to_end_list_##type(var_list); var_list->current_list; decrement_list_##type(var_list))
+
+
+#define IMPLEMENTATION_LIST(type)\
+  \
+  struct main_list_##type *create_var_list_##type(){\
+    struct main_list_##type *ret_var_list = malloc(sizeof(struct main_list_##type));\
+    ret_var_list->begin_list = NULL;\
+    ret_var_list->end_list = NULL;\
+    ret_var_list->current_list = NULL;\
+    ret_var_list->current_index = 0;\
+    ret_var_list->size = 0;\
+    return ret_var_list;\
+  }\
+  void push_back_list_##type(struct main_list_##type *var_list, type value){\
+    struct list_##type * list_to_add = malloc(sizeof(struct list_##type));\
+    list_to_add->value = value;\
+    list_to_add->index = var_list->size;\
+    list_to_add->preview = var_list->end_list;\
+    list_to_add->next = NULL;\
+    if(var_list->end_list){\
+      (var_list->end_list)->next = list_to_add;\
+    }else {\
+      var_list->begin_list = list_to_add;\
+      var_list->current_list= list_to_add;\
+      var_list->current_index=0;\
+    }\
+    var_list->end_list = list_to_add;\
+    ++(var_list->size);\
+  }\
+  void push_front_list_##type(struct main_list_##type *var_list, type value){\
+    struct list_##type * list_to_add = malloc(sizeof(struct list_##type));\
+    list_to_add->value = value;\
+    list_to_add->preview = NULL;\
+    list_to_add->next = var_list->begin_list;\
+    if(var_list->begin_list){\
+      (var_list->begin_list)->preview = list_to_add;\
+      ++(var_list->current_index);\
+    }else {\
+      var_list->end_list = list_to_add;\
+      var_list->current_list= list_to_add;\
+      var_list->current_index=0;\
+    }\
+    var_list->begin_list = list_to_add;\
+    ++(var_list->size);\
+    size_t index=0;\
+    while(list_to_add){\
+      list_to_add->index = index++;\
+      list_to_add = list_to_add->next;\
+    }\
+  }\
+  size_t move_current_to_index_list_##type(struct main_list_##type *var_list, size_t index, struct list_##type **list_in_index){\
+    if(var_list->current_list==NULL) {;\
+      if(index <= var_list->size - 1 - index){\
+        var_list->current_list = var_list->begin_list;\
+      }else{\
+      var_list->current_list = var_list->end_list;\
+      }\
+    }\
+    if(index == var_list->current_list->index){\
+      if(list_in_index) *list_in_index = var_list->current_list;\
+      return index;\
+    }\
+    if(var_list->begin_list == NULL){\
+      if(list_in_index) *list_in_index=NULL;\
+      return 0;\
+    }\
+    if(index >= var_list->size){\
+      var_list->current_list = var_list->end_list;\
+      var_list->current_index = var_list->size - 1;\
+      if(list_in_index) *list_in_index = var_list->current_list;\
+      return var_list->current_list->index /*size - 1*/;\
+    }\
+    /*if((var_list->current_list->index >= var_list->size) || !(var_list->current_list)){\
+      var_list->current_list = var_list->end_list;\
+      var_list->current_index = var_list->size - 1;\
+    }*/\
+    long from_current_index = var_list->current_list->index - index; \
+    size_t abs_cur_diff = abs(from_current_index); \
+    size_t array_diff_index[3]  = {index, abs_cur_diff , var_list->size - 1 - index}; \
+    size_t index_nearest = ARG_MIN_ARRAY_TYPE_SIZE_T(array_diff_index, 3);\
+    if(index_nearest == 0){\
+      var_list->current_list = var_list->begin_list;\
+      for(size_t i=0; i<array_diff_index[0]; ++i) var_list->current_list = (var_list->current_list)->next; \
+    }\
+    else if(index_nearest == 2){\
+      var_list->current_list = var_list->end_list;\
+      for(size_t i=0; i < array_diff_index[2]; ++i) var_list->current_list = (var_list->current_list)->preview; \
+    }else if(from_current_index >= 0) \
+      for(size_t i=0; i < array_diff_index[1]; ++i) var_list->current_list = (var_list->current_list)->preview; \
+    else  \
+      for(size_t i=0; i < array_diff_index[1]; ++i) var_list->current_list = (var_list->current_list)->next; \
+      \
+    var_list->current_index = index;\
+    if(list_in_index) *list_in_index = var_list->current_list;\
+    return index;\
+  }\
+  size_t move_current_to_begin_list_##type(struct main_list_##type *var_list){\
+    if(var_list->begin_list == NULL){\
+      return 0;\
+    }\
+    var_list->current_list = var_list->begin_list;\
+    var_list->current_index = 0;\
+    return 0;\
+  }\
+  size_t move_current_to_end_list_##type(struct main_list_##type *var_list){\
+    if(var_list->end_list == NULL){\
+      return 0;\
+    }\
+    var_list->current_list = var_list->end_list;\
+    var_list->current_index = var_list->size - 1;\
+    return var_list->current_index;\
+  }\
+  size_t insert_into_list_##type(struct main_list_##type *var_list, size_t index, type value ){\
+    struct list_##type * list_to_add = malloc(sizeof(struct list_##type));\
+    size_t ii=0;\
+    list_to_add->value = value;\
+    if(var_list->begin_list == NULL){\
+      list_to_add->preview = NULL;\
+      list_to_add->next = NULL;\
+      var_list->begin_list = list_to_add;\
+      var_list->end_list = list_to_add;\
+      var_list->current_list = list_to_add;\
+      var_list->current_index = 0;\
+      \
+    }else {\
+      struct list_##type *current_list;\
+      ii =  move_current_to_index_list_##type(var_list, index, &current_list);\
+      if(index > ii)\
+        printf("%ld out of range, we  put the value at %ld index of the list \n",index, ii);\
+      if(current_list){\
+        struct list_##type *prev_list = (current_list)->preview;\
+        list_to_add->preview = prev_list;\
+        list_to_add->next = current_list;\
+        if(list_to_add->preview == NULL){\
+          var_list->begin_list = list_to_add;\
+        }else\
+          prev_list->next = list_to_add;\
+        if(list_to_add->next == NULL)\
+          var_list->end_list = list_to_add;\
+        (current_list)->preview = list_to_add;\
+        var_list->current_list = list_to_add;\
+        var_list->current_index = ii;\
+      }\
+    }\
+    ++(var_list->size);\
+    size_t local_ii = ii;\
+    while(list_to_add){\
+      list_to_add->index = local_ii++;\
+      list_to_add = list_to_add->next;\
+    }\
+    return ii;\
+  }\
+  void remove_index_from_list_##type(struct main_list_##type *var_list, size_t index ){\
+    struct list_##type *current_list;\
+    if( index == move_current_to_index_list_##type(var_list, index, &current_list)) {\
+      struct list_##type * list_tmp_prev = (current_list)->preview;\
+      struct list_##type * list_tmp_next = (current_list)->next;\
+      if(list_tmp_prev){\
+        list_tmp_prev->next = list_tmp_next;\
+        if(list_tmp_next){\
+          list_tmp_next->preview = list_tmp_prev;\
+          var_list->current_list = list_tmp_next;\
+        }\
+        else {\
+          var_list->end_list = list_tmp_prev;\
+          var_list->current_list = list_tmp_prev;\
+        }\
+      }else{\
+        var_list->begin_list = list_tmp_next;\
+        if(list_tmp_next) {\
+          list_tmp_next->preview = list_tmp_prev;\
+        }\
+        else{\
+          var_list->end_list = NULL;\
+          var_list->current_list = NULL;\
+        }\
+      }\
+      free(current_list);\
+      --(var_list->size);\
+      while(list_tmp_next){\
+        list_tmp_next->index = index++;\
+        list_tmp_next=list_tmp_next->next;\
+      }\
+    }\
+  }\
+  struct list_##type * pull_index_from_list_##type(struct main_list_##type *var_list, size_t index ){\
+    struct list_##type *current_list=NULL;\
+    if( index == move_current_to_index_list_##type(var_list, index, &current_list)) {\
+      struct list_##type * list_tmp_prev = (current_list)->preview;\
+      struct list_##type * list_tmp_next = (current_list)->next;\
+      if(list_tmp_prev){\
+        list_tmp_prev->next = list_tmp_next;\
+        if(list_tmp_next){\
+          list_tmp_next->preview = list_tmp_prev;\
+          var_list->current_list = list_tmp_next;\
+        }\
+        else {\
+          var_list->end_list = list_tmp_prev;\
+          var_list->current_list = list_tmp_prev;\
+        }\
+      }else{\
+        var_list->begin_list = list_tmp_next;\
+        if(list_tmp_next) {\
+          list_tmp_next->preview = list_tmp_prev;\
+        }\
+        else{\
+          var_list->end_list = NULL;\
+          var_list->current_list = NULL;\
+        }\
+      }\
+      --(var_list->size);\
+      while(list_tmp_next){\
+        list_tmp_next->index = index++;\
+        list_tmp_next=list_tmp_next->next;\
+      }\
+    }\
+    return current_list;\
+  }\
+  void remove_all_list_in_##type(struct main_list_##type *var_list){\
+    struct list_##type *tmp = var_list->begin_list, *prec_tmp;\
+    while(tmp){\
+      prec_tmp = tmp;\
+      tmp = tmp->next;\
+      free(prec_tmp);\
+    }\
+    var_list->begin_list = NULL;\
+    var_list->current_list = NULL;\
+    var_list->end_list = NULL;\
+    var_list->size = 0;\
+    var_list->current_index = 0;\
+  }\
+  void free_all_var_list_##type(struct main_list_##type *var_list){\
+    remove_all_list_in_##type(var_list);\
+    free(var_list);\
+  }\
+  void increment_list_##type(struct main_list_##type * var_list){\
+    var_list->current_list = (var_list->current_list)->next;\
+    ++(var_list->current_index);\
+  }\
+  void decrement_list_##type(struct main_list_##type * var_list){\
+    var_list->current_list = (var_list->current_list)->preview;\
+    --(var_list->current_index);\
+  }\
+  struct list_##type * local_increment_list_##type(struct list_##type *list){\
+    if(list) return list->next;\
+    return NULL;\
+  }\
+  struct list_##type * local_decrement_list_##type(struct list_##type *list){\
+    if (list) return list->preview;\
+    return NULL;\
+  }\
+  struct list_##type * search_first_occ_with_mov_from_curr_in_list_##type(struct main_list_##type *var_list, type value, int (*funcCmp)(type, type), struct list_##type * (*incr_or_decr_mov)(struct list_##type *)){\
+    for(struct list_##type *list_cur = var_list->current_list; list_cur; list_cur = incr_or_decr_mov(list_cur)){\
+      if(0 == funcCmp(value, list_cur->value)){\
+        return list_cur;\
+      }\
+    }\
+    return NULL;\
+  }\
+  struct list_##type * search_first_occ_from_begin_in_list_##type(struct main_list_##type *var_list, type value, int (*funcCmp)(type, type)){\
+    /*printf("debug: cur_index change to 0");*/\
+    var_list->current_list = var_list->begin_list;\
+    return search_first_occ_with_mov_from_curr_in_list_##type(var_list, value, funcCmp, local_increment_list_##type);\
+  }\
+  struct list_##type * search_first_occ_from_end_in_list_##type(struct main_list_##type *var_list, type value, int (*funcCmp)(type, type)){\
+    /*printf("debug: cur_index change to end");*/\
+    var_list->current_list = var_list->end_list;\
+    return search_first_occ_with_mov_from_curr_in_list_##type(var_list, value, funcCmp, local_decrement_list_##type);\
+  }\
+  struct list_##type * pull_end_from_list_##type(struct main_list_##type *var_list){\
+    struct list_##type *ret = var_list->end_list;\
+    if(ret != NULL){\
+      struct list_##type * prevL = ret->preview;\
+      if(prevL != NULL){\
+        prevL->next=NULL;\
+      }else{\
+        var_list->begin_list=NULL;\
+        var_list->current_index = 0;\
+        var_list->current_list=NULL;\
+      }\
+      var_list->end_list = prevL;\
+      --(var_list->size);\
+      ret->preview = NULL;\
+    }\
+    return ret;\
+  }\
+  struct list_##type * pull_begin_from_list_##type(struct main_list_##type *var_list){\
+    struct list_##type *ret = var_list->begin_list;\
+    if(ret != NULL){\
+      struct list_##type * nextL = ret->next;\
+      if(nextL != NULL){\
+        nextL->preview=NULL;\
+      }else{\
+        var_list->end_list=NULL;\
+        var_list->current_index = 0;\
+        var_list->current_list=NULL;\
+      }\
+      var_list->begin_list = nextL;\
+      --(var_list->size);\
+      ret->next = NULL;\
+    }\
+    struct list_##type *tmp = var_list->begin_list;\
+    while(tmp){ --(tmp->index); tmp=tmp->next;}\
+    return ret;\
+  }\
+  void append_list_##type(struct main_list_##type *var_list, struct list_##type *list){\
+    list->index = var_list->size;\
+    if(var_list->end_list == NULL){\
+      list->preview = NULL;\
+      var_list->end_list = list;\
+      var_list->begin_list = list;\
+      var_list->current_list = list;\
+      var_list->current_index = 0;\
+    }else{\
+      var_list->end_list->next = list;\
+      list->preview = var_list->end_list;\
+      var_list->end_list = list;\
+    }\
+    ++(var_list->size);\
+  }\
+  
+
+#define GEN_HEAD_PTR_LIST(type)\
+  void remove_all_ptr_type_list_##type(struct main_list_##type *var_list);\
+  void purge_ptr_type_list_##type(struct main_list_##type *var_list);\
+  void free_##type(type arg);\
+
+
+
+#define GEN_FUNC_PTR_LIST_FREE(type)\
+  void remove_all_ptr_type_list_##type(struct main_list_##type *var_list){\
+    struct list_##type *tmp = var_list->begin_list, *prec_tmp;\
+    while(tmp){\
+      prec_tmp = tmp;\
+      tmp = tmp->next;\
+      free_##type(prec_tmp->value);\
+      free(prec_tmp);\
+    }\
+    var_list->begin_list = NULL;\
+    var_list->current_list = NULL;\
+    var_list->end_list = NULL;\
+    var_list->size = 0;\
+    var_list->current_index = 0;\
+  }\
+  void purge_ptr_type_list_##type(struct main_list_##type *var_list){\
+    remove_all_ptr_type_list_##type(var_list);\
+		free(var_list);\
+  }\
+  \
+  void free_##type(type arg)\
+
+
+#define LIST_T(type) \
+    CREATE_HEADER_LIST(type)\
+    IMPLEMENTATION_LIST(type)
+
+#define LIST_PTR_T_FREE(type) \
+    CREATE_HEADER_LIST(type)\
+    IMPLEMENTATION_LIST(type)\
+    GEN_HEAD_PTR_LIST(type)\
+    GEN_FUNC_PTR_LIST_FREE(type)
+
+
+
+
+#endif /* __LIST_T_C__H */
+
diff --git a/list_t/src/list_t/list_t.c b/list_t/src/list_t/list_t.c
new file mode 100755
index 0000000..873dc6f
--- /dev/null
+++ b/list_t/src/list_t/list_t.c
@@ -0,0 +1,155 @@
+
+#include "list_t/list_t.h"
+
+#if 0
+
+#define GEN_LIST_ALL_L(type)\
+ \
+  struct main_list_##type *create_var_list_##type(){\
+    struct main_list_##type *ret_var_list = malloc(sizeof(struct main_list_##type));\
+    ret_var_list->begin_list = NULL;\
+    ret_var_list->end_list = NULL;\
+    ret_var_list->current_list = NULL;\
+    ret_var_list->current_index = 0;\
+    ret_var_list->size = 0;\
+    return ret_var_list;\
+  }\
+  void push_back_list_##type(struct main_list_##type *var_list, type value){\
+    struct list_##type * list_to_add = malloc(sizeof(struct list_##type));\
+    list_to_add->value = value;\
+    list_to_add->preview = var_list->end_list;\
+    list_to_add->next = NULL;\
+    if(var_list->end_list){\
+      (var_list->end_list)->next = list_to_add;\
+    }else {\
+      var_list->begin_list = list_to_add;\
+      var_list->current_list= list_to_add;\
+    }\
+    var_list->end_list = list_to_add;\
+    ++(var_list->size);\
+  }\
+  void push_front_list_##type(struct main_list_##type *var_list, type value){\
+    struct list_##type * list_to_add = malloc(sizeof(struct list_##type));\
+    list_to_add->value = value;\
+    list_to_add->preview = NULL;\
+    list_to_add->next = var_list->begin_list;\
+    if(var_list->begin_list){\
+      (var_list->begin_list)->preview = list_to_add;\
+      ++(var_list->current_index);\
+    }else {\
+      var_list->end_list = list_to_add;\
+      var_list->current_list= list_to_add;\
+    }\
+    var_list->begin_list = list_to_add;\
+    ++(var_list->size);\
+  }\
+  size_t move_current_to_index_list_##type(struct main_list_##type *var_list, size_t index){\
+    if(index == var_list->current_index) return index;\
+    if(var_list->begin_list == NULL) return 0;\
+    if(index >= var_list->size){\
+      var_list->current_list = var_list->end_list;\
+      var_list->current_index = var_list->size - 1;\
+      return var_list->size - 1;\
+    }\
+    if((var_list->current_index >= var_list->size) || !(var_list->current_list)){\
+      var_list->current_list = var_list->end_list;\
+      var_list->current_index = var_list->size - 1;\
+    }\
+    long from_current_index = var_list->current_index - index; \
+    size_t abs_cur_diff = abs(from_current_index); \
+    size_t array_diff_index[3]  = {index, abs_cur_diff , var_list->size - 1 - index}; \
+    size_t index_nearest = ARG_MIN_ARRAY_TYPE_SIZE_T(array_diff_index, 3);\
+    if(index_nearest == 0){\
+      var_list->current_list = var_list->begin_list;\
+      for(size_t i=0; i<array_diff_index[0]; ++i) var_list->current_list = (var_list->current_list)->next; \
+    }\
+    else if(index_nearest == 2){\
+      var_list->current_list = var_list->end_list;\
+      for(size_t i=0; i < array_diff_index[0]; ++i) var_list->current_list = (var_list->current_list)->preview; \
+    }else if(from_current_index >= 0) \
+      for(size_t i=0; i < array_diff_index[1]; ++i) var_list->current_list = (var_list->current_list)->preview; \
+    else  \
+      for(size_t i=0; i < array_diff_index[1]; ++i) var_list->current_list = (var_list->current_list)->next; \
+      \
+    var_list->current_index = index;\
+    return index;\
+  }\
+  void insert_into_list_##type(struct main_list_##type *var_list, size_t index, type value ){\
+    struct list_##type * list_to_add = malloc(sizeof(struct list_##type));\
+    list_to_add->value = value;\
+    if(var_list->begin_list == NULL){\
+      list_to_add->preview = NULL;\
+      list_to_add->next = NULL;\
+      var_list->begin_list = list_to_add;\
+      var_list->end_list = list_to_add;\
+      var_list->current_list = list_to_add;\
+      var_list->current_index = 0;\
+      \
+    }else {\
+      size_t ii =  move_current_to_index_list_##type(var_list, index);\
+      if(index > ii)\
+        printf("%ld out of range, we  put the value at %ld index of the list \n",index, ii);\
+      if(var_list->current_list){\
+        list_to_add->preview = (var_list->current_list)->preview;\
+        list_to_add->next = var_list->current_list;\
+        if(list_to_add->preview)\
+          (list_to_add->preview)->next = list_to_add;\
+        else var_list->begin_list = list_to_add;\
+        (var_list->current_list)->preview = list_to_add;\
+        var_list->current_list = list_to_add;\
+      }\
+    }\
+    ++(var_list->size);\
+  }\
+  void remove_index_from_list_##type(struct main_list_##type *var_list, size_t index ){\
+    if( index == move_current_to_index_list_##type(var_list, index)) {\
+      struct list_##type * list_tmp_prev = (var_list->current_list)->preview;\
+      struct list_##type * list_tmp_next = (var_list->current_list)->next;\
+      if(list_tmp_prev){\
+        list_tmp_prev->next = list_tmp_next;\
+        if(list_tmp_next)  list_tmp_next->preview = list_tmp_prev;\
+      }\
+      free(var_list->current_list);\
+      var_list->current_list = list_tmp_next;\
+      --(var_list->size);\
+      \
+    }\
+  }\
+  void free_all_var_list_##type(struct main_list_##type *var_list){\
+    struct list_##type *tmp = var_list->begin_list;\
+    while(tmp){\
+      var_list->current_list = tmp;\
+      tmp = tmp->next;\
+      free(var_list->current_list);\
+    }\
+    free(var_list);\
+  }\
+  void increment_list_##type(struct main_list_##type * var_list){\
+    var_list->current_list = (var_list->current_list)->next;\
+    ++(var_list->current_index);\
+  }\
+  void decrement_list_##type(struct main_list_##type * var_list){\
+    var_list->current_list = (var_list->current_list)->preview;\
+    --(var_list->current_index);\
+  }\
+  
+#endif
+
+
+GEN_LIST_ALL(TYPE_CHAR)
+GEN_LIST_ALL(TYPE_U_CHAR)
+GEN_LIST_ALL(TYPE_INT)
+GEN_LIST_ALL(TYPE_U_INT)
+GEN_LIST_ALL(TYPE_L_INT)
+GEN_LIST_ALL(TYPE_U_L_INT)
+GEN_LIST_ALL(TYPE_SIZE_T)
+GEN_LIST_ALL(TYPE_FLOAT)
+GEN_LIST_ALL(TYPE_DOUBLE)
+GEN_LIST_ALL(TYPE_L_DOUBLE)
+GEN_LIST_ALL(TYPE_STRING)
+
+GEN_LIST_ALL(TYPE_PTR)
+
+GEN_FUNC_PTR_LIST_FREE(TYPE_PTR){
+  free(arg);
+}
diff --git a/list_t/src/list_t/list_t.h b/list_t/src/list_t/list_t.h
new file mode 100644
index 0000000..35b4935
--- /dev/null
+++ b/list_t/src/list_t/list_t.h
@@ -0,0 +1,478 @@
+#ifndef __LIST_T_C__H
+#define __LIST_T_C__H
+
+#include <pthread.h>
+
+#include "tools_t/tools_t.h"
+
+#define TYPE_PTR void*
+
+#define GENERATE_LIST_ALL(type)\
+  struct list_##type {\
+    type value;\
+    size_t index;\
+    struct list_##type *preview;\
+    struct list_##type *next;\
+  };\
+  struct main_list_##type {\
+    struct list_##type *begin_list;\
+    struct list_##type *current_list;\
+    size_t current_index;\
+    struct list_##type *end_list;\
+    size_t size;\
+    pthread_mutex_t *mut_list;\
+  };\
+  struct main_list_##type *create_var_list_##type();\
+  void push_back_list_##type(struct main_list_##type *var_list, type value);\
+  void push_front_list_##type(struct main_list_##type *var_list, type value);\
+  size_t move_current_to_index_list_##type(struct main_list_##type *var_list, size_t index, struct list_##type **list_in_index);\
+  size_t move_current_to_begin_list_##type(struct main_list_##type *var_list);\
+  size_t move_current_to_end_list_##type(struct main_list_##type *var_list);\
+  size_t insert_into_list_##type(struct main_list_##type *var_list, size_t index, type value );\
+  void remove_index_from_list_##type(struct main_list_##type *var_list, size_t index );\
+  struct list_##type* pull_index_from_list_##type(struct main_list_##type *var_list, size_t index );\
+  void free_all_var_list_##type(struct main_list_##type *var_list);\
+  void remove_all_list_in_##type(struct main_list_##type *var_list);\
+  void increment_list_##type(struct main_list_##type * var_list);\
+  void decrement_list_##type(struct main_list_##type * var_list);\
+  struct list_##type * search_first_occ_with_mov_from_curr_in_list_##type(struct main_list_##type *var_list, type value, int (*funcCmp)(type, type),  struct list_##type * (*incr_or_decr_mov)(struct list_##type *));\
+  struct list_##type * search_first_occ_from_begin_in_list_##type(struct main_list_##type *var_list, type value, int (*funcCmp)(type, type));\
+  struct list_##type * search_first_occ_from_end_in_list_##type(struct main_list_##type *var_list, type value, int (*funcCmp)(type, type));\
+  struct list_##type * pull_end_from_list_##type(struct main_list_##type *var_list);\
+  struct list_##type * pull_begin_from_list_##type(struct main_list_##type *var_list);\
+  void append_list_##type(struct main_list_##type *var_list, struct list_##type *list);\
+  struct list_##type * local_increment_list_##type(struct list_##type *list);\
+  struct list_##type * local_decrement_list_##type(struct list_##type *list);\
+ 
+
+GENERATE_LIST_ALL(TYPE_CHAR)
+GENERATE_LIST_ALL(TYPE_U_CHAR)
+GENERATE_LIST_ALL(TYPE_INT)
+GENERATE_LIST_ALL(TYPE_U_INT)
+GENERATE_LIST_ALL(TYPE_L_INT)
+GENERATE_LIST_ALL(TYPE_U_L_INT)
+GENERATE_LIST_ALL(TYPE_SIZE_T)
+GENERATE_LIST_ALL(TYPE_FLOAT)
+GENERATE_LIST_ALL(TYPE_DOUBLE)
+GENERATE_LIST_ALL(TYPE_L_DOUBLE)
+GENERATE_LIST_ALL(TYPE_STRING)
+
+GENERATE_LIST_ALL(TYPE_PTR)
+
+#define FOR_LIST_FORM_BEGIN(type, var_list)\
+  for(move_current_to_begin_list_##type(var_list); var_list->current_list; increment_list_##type(var_list))
+
+#define FOR_LIST_FORM_END(type, var_list)\
+  for(move_current_to_end_list_##type(var_list); var_list->current_list; decrement_list_##type(var_list))
+
+
+#define GEN_LIST_ALL(type)\
+  \
+  struct main_list_##type *create_var_list_##type(){\
+    struct main_list_##type *ret_var_list = malloc(sizeof(struct main_list_##type));\
+    ret_var_list->begin_list = NULL;\
+    ret_var_list->end_list = NULL;\
+    ret_var_list->current_list = NULL;\
+    ret_var_list->current_index = 0;\
+    ret_var_list->size = 0;\
+    ret_var_list->mut_list = malloc(sizeof(pthread_mutex_t));\
+    pthread_mutex_init(ret_var_list->mut_list, NULL);\
+    return ret_var_list;\
+  }\
+  void push_back_list_##type(struct main_list_##type *var_list, type value){\
+    struct list_##type * list_to_add = malloc(sizeof(struct list_##type));\
+    list_to_add->value = value;\
+    pthread_mutex_lock(var_list->mut_list);\
+    list_to_add->index = var_list->size;\
+    list_to_add->preview = var_list->end_list;\
+    list_to_add->next = NULL;\
+    if(var_list->end_list){\
+      (var_list->end_list)->next = list_to_add;\
+    }else {\
+      var_list->begin_list = list_to_add;\
+      var_list->current_list= list_to_add;\
+      var_list->current_index=0;\
+    }\
+    var_list->end_list = list_to_add;\
+    ++(var_list->size);\
+    pthread_mutex_unlock(var_list->mut_list);\
+  }\
+  void push_front_list_##type(struct main_list_##type *var_list, type value){\
+    struct list_##type * list_to_add = malloc(sizeof(struct list_##type));\
+    list_to_add->value = value;\
+    list_to_add->preview = NULL;\
+    pthread_mutex_lock(var_list->mut_list);\
+    list_to_add->next = var_list->begin_list;\
+    if(var_list->begin_list){\
+      (var_list->begin_list)->preview = list_to_add;\
+      ++(var_list->current_index);\
+    }else {\
+      var_list->end_list = list_to_add;\
+      var_list->current_list= list_to_add;\
+      var_list->current_index=0;\
+    }\
+    var_list->begin_list = list_to_add;\
+    ++(var_list->size);\
+    size_t index=0;\
+    while(list_to_add){\
+      list_to_add->index = index++;\
+      list_to_add = list_to_add->next;\
+    }\
+    pthread_mutex_unlock(var_list->mut_list);\
+  }\
+  size_t move_current_to_index_list_##type(struct main_list_##type *var_list, size_t index, struct list_##type **list_in_index){\
+    pthread_mutex_lock(var_list->mut_list);\
+    if(var_list->current_list==NULL) {;\
+      if(index <= var_list->size - 1 - index){\
+        var_list->current_list = var_list->begin_list;\
+      }else{\
+      var_list->current_list = var_list->end_list;\
+      }\
+    }\
+    if(index == var_list->current_list->index){\
+      if(list_in_index) *list_in_index = var_list->current_list;\
+      pthread_mutex_unlock(var_list->mut_list);\
+      return index;\
+    }\
+    if(var_list->begin_list == NULL){\
+      if(list_in_index) *list_in_index=NULL;\
+      pthread_mutex_unlock(var_list->mut_list);\
+      return 0;\
+    }\
+    if(index >= var_list->size){\
+      var_list->current_list = var_list->end_list;\
+      var_list->current_index = var_list->size - 1;\
+      if(list_in_index) *list_in_index = var_list->current_list;\
+      pthread_mutex_unlock(var_list->mut_list);\
+      return var_list->current_list->index /*size - 1*/;\
+    }\
+    /*if((var_list->current_list->index >= var_list->size) || !(var_list->current_list)){\
+      var_list->current_list = var_list->end_list;\
+      var_list->current_index = var_list->size - 1;\
+    }*/\
+    long from_current_index = var_list->current_list->index - index; \
+    size_t abs_cur_diff = abs(from_current_index); \
+    size_t array_diff_index[3]  = {index, abs_cur_diff , var_list->size - 1 - index}; \
+    size_t index_nearest = ARG_MIN_ARRAY_TYPE_SIZE_T(array_diff_index, 3);\
+    if(index_nearest == 0){\
+      var_list->current_list = var_list->begin_list;\
+      for(size_t i=0; i<array_diff_index[0]; ++i) var_list->current_list = (var_list->current_list)->next; \
+    }\
+    else if(index_nearest == 2){\
+      var_list->current_list = var_list->end_list;\
+      for(size_t i=0; i < array_diff_index[2]; ++i) var_list->current_list = (var_list->current_list)->preview; \
+    }else if(from_current_index >= 0) \
+      for(size_t i=0; i < array_diff_index[1]; ++i) var_list->current_list = (var_list->current_list)->preview; \
+    else  \
+      for(size_t i=0; i < array_diff_index[1]; ++i) var_list->current_list = (var_list->current_list)->next; \
+      \
+    var_list->current_index = index;\
+    if(list_in_index) *list_in_index = var_list->current_list;\
+    pthread_mutex_unlock(var_list->mut_list);\
+    return index;\
+  }\
+  size_t move_current_to_begin_list_##type(struct main_list_##type *var_list){\
+    pthread_mutex_lock(var_list->mut_list);\
+    if(var_list->begin_list == NULL){\
+      pthread_mutex_unlock(var_list->mut_list);\
+      return 0;\
+    }\
+    var_list->current_list = var_list->begin_list;\
+    var_list->current_index = 0;\
+    pthread_mutex_unlock(var_list->mut_list);\
+    return 0;\
+  }\
+  size_t move_current_to_end_list_##type(struct main_list_##type *var_list){\
+    pthread_mutex_lock(var_list->mut_list);\
+    if(var_list->end_list == NULL){\
+      pthread_mutex_unlock(var_list->mut_list);\
+      return 0;\
+    }\
+    var_list->current_list = var_list->end_list;\
+    var_list->current_index = var_list->size - 1;\
+    pthread_mutex_unlock(var_list->mut_list);\
+    return var_list->current_index;\
+  }\
+  size_t insert_into_list_##type(struct main_list_##type *var_list, size_t index, type value ){\
+    struct list_##type * list_to_add = malloc(sizeof(struct list_##type));\
+    size_t ii=0;\
+    list_to_add->value = value;\
+    if(var_list->begin_list == NULL){\
+      pthread_mutex_lock(var_list->mut_list);\
+      list_to_add->preview = NULL;\
+      list_to_add->next = NULL;\
+      var_list->begin_list = list_to_add;\
+      var_list->end_list = list_to_add;\
+      var_list->current_list = list_to_add;\
+      var_list->current_index = 0;\
+      \
+    }else {\
+      struct list_##type *current_list;\
+      ii =  move_current_to_index_list_##type(var_list, index, &current_list);\
+      pthread_mutex_lock(var_list->mut_list);\
+      if(index > ii)\
+        printf("%ld out of range, we  put the value at %ld index of the list \n",index, ii);\
+      if(current_list){\
+        struct list_##type *prev_list = (current_list)->preview;\
+        list_to_add->preview = prev_list;\
+        list_to_add->next = current_list;\
+        if(list_to_add->preview == NULL){\
+          var_list->begin_list = list_to_add;\
+        }else\
+          prev_list->next = list_to_add;\
+        if(list_to_add->next == NULL)\
+          var_list->end_list = list_to_add;\
+        (current_list)->preview = list_to_add;\
+        var_list->current_list = list_to_add;\
+        var_list->current_index = ii;\
+      }\
+    }\
+    ++(var_list->size);\
+    size_t local_ii = ii;\
+    while(list_to_add){\
+      list_to_add->index = local_ii++;\
+      list_to_add = list_to_add->next;\
+    }\
+    pthread_mutex_unlock(var_list->mut_list);\
+    return ii;\
+  }\
+  void remove_index_from_list_##type(struct main_list_##type *var_list, size_t index ){\
+    struct list_##type *current_list;\
+    if( index == move_current_to_index_list_##type(var_list, index, &current_list)) {\
+      pthread_mutex_lock(var_list->mut_list);\
+      struct list_##type * list_tmp_prev = (current_list)->preview;\
+      struct list_##type * list_tmp_next = (current_list)->next;\
+      if(list_tmp_prev){\
+        list_tmp_prev->next = list_tmp_next;\
+        if(list_tmp_next){\
+          list_tmp_next->preview = list_tmp_prev;\
+          var_list->current_list = list_tmp_next;\
+        }\
+        else {\
+          var_list->end_list = list_tmp_prev;\
+          var_list->current_list = list_tmp_prev;\
+        }\
+      }else{\
+        var_list->begin_list = list_tmp_next;\
+        if(list_tmp_next) {\
+          list_tmp_next->preview = list_tmp_prev;\
+        }\
+        else{\
+          var_list->end_list = NULL;\
+          var_list->current_list = NULL;\
+        }\
+      }\
+      free(current_list);\
+      --(var_list->size);\
+      while(list_tmp_next){\
+        list_tmp_next->index = index++;\
+        list_tmp_next=list_tmp_next->next;\
+      }\
+      pthread_mutex_unlock(var_list->mut_list);\
+    }\
+  }\
+  struct list_##type * pull_index_from_list_##type(struct main_list_##type *var_list, size_t index ){\
+    struct list_##type *current_list=NULL;\
+    if( index == move_current_to_index_list_##type(var_list, index, &current_list)) {\
+      pthread_mutex_lock(var_list->mut_list);\
+      struct list_##type * list_tmp_prev = (current_list)->preview;\
+      struct list_##type * list_tmp_next = (current_list)->next;\
+      if(list_tmp_prev){\
+        list_tmp_prev->next = list_tmp_next;\
+        if(list_tmp_next){\
+          list_tmp_next->preview = list_tmp_prev;\
+          var_list->current_list = list_tmp_next;\
+        }\
+        else {\
+          var_list->end_list = list_tmp_prev;\
+          var_list->current_list = list_tmp_prev;\
+        }\
+      }else{\
+        var_list->begin_list = list_tmp_next;\
+        if(list_tmp_next) {\
+          list_tmp_next->preview = list_tmp_prev;\
+        }\
+        else{\
+          var_list->end_list = NULL;\
+          var_list->current_list = NULL;\
+        }\
+      }\
+      --(var_list->size);\
+      while(list_tmp_next){\
+        list_tmp_next->index = index++;\
+        list_tmp_next=list_tmp_next->next;\
+      }\
+      pthread_mutex_unlock(var_list->mut_list);\
+    }\
+    return current_list;\
+  }\
+  void remove_all_list_in_##type(struct main_list_##type *var_list){\
+    pthread_mutex_lock(var_list->mut_list);\
+    struct list_##type *tmp = var_list->begin_list, *prec_tmp;\
+    while(tmp){\
+      prec_tmp = tmp;\
+      tmp = tmp->next;\
+      free(prec_tmp);\
+    }\
+    var_list->begin_list = NULL;\
+    var_list->current_list = NULL;\
+    var_list->end_list = NULL;\
+    var_list->size = 0;\
+    var_list->current_index = 0;\
+    pthread_mutex_unlock(var_list->mut_list);\
+  }\
+  void free_all_var_list_##type(struct main_list_##type *var_list){\
+    remove_all_list_in_##type(var_list);\
+    pthread_mutex_destroy(var_list->mut_list);\
+    free(var_list->mut_list);\
+    free(var_list);\
+  }\
+  void increment_list_##type(struct main_list_##type * var_list){\
+    pthread_mutex_lock(var_list->mut_list);\
+    var_list->current_list = (var_list->current_list)->next;\
+    ++(var_list->current_index);\
+    pthread_mutex_unlock(var_list->mut_list);\
+  }\
+  void decrement_list_##type(struct main_list_##type * var_list){\
+    pthread_mutex_lock(var_list->mut_list);\
+    var_list->current_list = (var_list->current_list)->preview;\
+    --(var_list->current_index);\
+    pthread_mutex_unlock(var_list->mut_list);\
+  }\
+  struct list_##type * local_increment_list_##type(struct list_##type *list){\
+    if(list) return list->next;\
+    return NULL;\
+  }\
+  struct list_##type * local_decrement_list_##type(struct list_##type *list){\
+    if (list) return list->preview;\
+    return NULL;\
+  }\
+  struct list_##type * search_first_occ_with_mov_from_curr_in_list_##type(struct main_list_##type *var_list, type value, int (*funcCmp)(type, type), struct list_##type * (*incr_or_decr_mov)(struct list_##type *)){\
+    pthread_mutex_lock(var_list->mut_list);\
+    for(struct list_##type *list_cur = var_list->current_list; list_cur; list_cur = incr_or_decr_mov(list_cur)){\
+      if(0 == funcCmp(value, list_cur->value)){\
+        pthread_mutex_unlock(var_list->mut_list);\
+        return list_cur;\
+      }\
+    }\
+    pthread_mutex_unlock(var_list->mut_list);\
+    return NULL;\
+  }\
+  struct list_##type * search_first_occ_from_begin_in_list_##type(struct main_list_##type *var_list, type value, int (*funcCmp)(type, type)){\
+    pthread_mutex_lock(var_list->mut_list);\
+    /*printf("debug: cur_index change to 0");*/\
+    var_list->current_list = var_list->begin_list;\
+    pthread_mutex_unlock(var_list->mut_list);\
+    return search_first_occ_with_mov_from_curr_in_list_##type(var_list, value, funcCmp, local_increment_list_##type);\
+  }\
+  struct list_##type * search_first_occ_from_end_in_list_##type(struct main_list_##type *var_list, type value, int (*funcCmp)(type, type)){\
+    pthread_mutex_lock(var_list->mut_list);\
+    /*printf("debug: cur_index change to end");*/\
+    var_list->current_list = var_list->end_list;\
+    pthread_mutex_unlock(var_list->mut_list);\
+    return search_first_occ_with_mov_from_curr_in_list_##type(var_list, value, funcCmp, local_decrement_list_##type);\
+  }\
+  struct list_##type * pull_end_from_list_##type(struct main_list_##type *var_list){\
+    pthread_mutex_lock(var_list->mut_list);\
+    struct list_##type *ret = var_list->end_list;\
+    if(ret != NULL){\
+      struct list_##type * prevL = ret->preview;\
+      if(prevL != NULL){\
+        prevL->next=NULL;\
+      }else{\
+        var_list->begin_list=NULL;\
+        var_list->current_index = 0;\
+        var_list->current_list=NULL;\
+      }\
+      var_list->end_list = prevL;\
+      --(var_list->size);\
+      ret->preview = NULL;\
+    }\
+    pthread_mutex_unlock(var_list->mut_list);\
+    return ret;\
+  }\
+  struct list_##type * pull_begin_from_list_##type(struct main_list_##type *var_list){\
+    pthread_mutex_lock(var_list->mut_list);\
+    struct list_##type *ret = var_list->begin_list;\
+    if(ret != NULL){\
+      struct list_##type * nextL = ret->next;\
+      if(nextL != NULL){\
+        nextL->preview=NULL;\
+      }else{\
+        var_list->end_list=NULL;\
+        var_list->current_index = 0;\
+        var_list->current_list=NULL;\
+      }\
+      var_list->begin_list = nextL;\
+      --(var_list->size);\
+      ret->next = NULL;\
+    }\
+    struct list_##type *tmp = var_list->begin_list;\
+    while(tmp){ --(tmp->index); tmp=tmp->next;}\
+    pthread_mutex_unlock(var_list->mut_list);\
+    return ret;\
+  }\
+  void append_list_##type(struct main_list_##type *var_list, struct list_##type *list){\
+    pthread_mutex_lock(var_list->mut_list);\
+    list->index = var_list->size;\
+    if(var_list->end_list == NULL){\
+      list->preview = NULL;\
+      var_list->end_list = list;\
+      var_list->begin_list = list;\
+      var_list->current_list = list;\
+      var_list->current_index = 0;\
+    }else{\
+      var_list->end_list->next = list;\
+      list->preview = var_list->end_list;\
+      var_list->end_list = list;\
+    }\
+    ++(var_list->size);\
+    pthread_mutex_unlock(var_list->mut_list);\
+  }\
+  
+
+#define GEN_HEAD_PTR_LIST(type)\
+  void remove_all_ptr_type_list_##type(struct main_list_##type *var_list);\
+  void purge_ptr_type_list_##type(struct main_list_##type *var_list);\
+  void free_##type(type arg);\
+
+
+
+#define GEN_FUNC_PTR_LIST_FREE(type)\
+  void remove_all_ptr_type_list_##type(struct main_list_##type *var_list){\
+    pthread_mutex_lock(var_list->mut_list);\
+    struct list_##type *tmp = var_list->begin_list, *prec_tmp;\
+    while(tmp){\
+      prec_tmp = tmp;\
+      tmp = tmp->next;\
+      free_##type(prec_tmp->value);\
+      free(prec_tmp);\
+    }\
+    var_list->begin_list = NULL;\
+    var_list->current_list = NULL;\
+    var_list->end_list = NULL;\
+    var_list->size = 0;\
+    var_list->current_index = 0;\
+    pthread_mutex_unlock(var_list->mut_list);\
+  }\
+  void purge_ptr_type_list_##type(struct main_list_##type *var_list){\
+    remove_all_ptr_type_list_##type(var_list);\
+    pthread_mutex_destroy(var_list->mut_list);\
+    free(var_list->mut_list);\
+		free(var_list);\
+  }\
+  \
+  void free_##type(type arg)\
+
+
+GEN_HEAD_PTR_LIST(TYPE_PTR)
+
+
+#define LIST_T(type) \
+    GENERATE_LIST_ALL(type)\
+    GEN_LIST_ALL(type)
+
+
+
+#endif /* __LIST_T_C__H */
+
diff --git a/list_t/src/list_t/list_t.o b/list_t/src/list_t/list_t.o
new file mode 100644
index 0000000000000000000000000000000000000000..bbe729fdc32a215ba275c54a8cce6000e9b6cb77
GIT binary patch
literal 101768
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
A8UO$Q

literal 0
HcmV?d00001

diff --git a/list_t/test/Makefile b/list_t/test/Makefile
new file mode 100644
index 0000000..ce2f155
--- /dev/null
+++ b/list_t/test/Makefile
@@ -0,0 +1,60 @@
+# file list_t/test/Makefile
+
+ROOTPROJECTDIR:=$(realpath ../..)
+
+NAME_TEST=is_good
+CC=gcc
+ROOT_DIR=$(ROOTPROJECTDIR)/list_t
+YTESTDIR=$(ROOTPROJECTDIR)/ytest_t
+
+INCLUDE_DIR=$(ROOT_DIR)/src
+CFLAGS=-I$(INCLUDE_DIR) -I$(YTESTDIR)/include_ytest/include
+LDFLAGS=-L$(YTESTDIR) -lytest
+
+#SRC_DIR=$(ROOT_DIR)/src
+#SRC=$(wildcard */*/*.c) 
+SRC=$(wildcard **/**/*.c) 
+#HEADS=$(OBJS:.o=.h)
+TEST_DIR=$(ROOT_DIR)/test
+EXECSRC=$(NAME_TEST).c
+EXEC=launch_$(NAME_TEST)_m
+
+LISTDIR=$(ROOT_DIR)
+
+LISTSRC_O=$(LISTDIR)/src/list_t/list_t.o
+
+TOPTARGETS := all clean 
+
+DEPS=$(LISTDIR) $(YTESTDIR)
+
+$(TOPTARGETS): $(DEPS) 
+
+$(DEPS):
+	$(MAKE) -C $@ $(MAKECMDGOALS)
+
+
+#LISTSRC_O=$(LISTSRC:.c=.o)
+#SETTSRC_O=$(PWD)/../src/set_theoric_t/set_theoric_t.o
+#SETTSRC_O=$(SETTSRC:.c=.o)
+#TOOLSRC=$(TOOLDIR)/src/tools_t/tools_t.c
+#TOOLSRC_O=$(TOOLSRC:.c=.o)
+
+OBJ=$(SRC:.c=.o) $(LISTSRC_O) 
+
+LIB_YTEST=$(YTESTDIR)/libytest.so
+
+all: $(EXEC) $(LIB_YTEST)
+
+$(EXEC):	$(EXECSRC) $(OBJ)
+	$(CC) -o $@ $^ $(CFLAGS) $(LDFLAGS)
+
+.PHONY: clean mrproper
+
+clean:
+	rm -f $(OBJ)
+
+mrproper: clean
+	rm -f $(EXEC)
+
+run: $(EXEC)
+	$(EXEC) -h
diff --git a/list_t/test/compile.sh b/list_t/test/compile.sh
new file mode 100755
index 0000000..91c319a
--- /dev/null
+++ b/list_t/test/compile.sh
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+if [ "$#" -le 0 ] ; then
+  echo "Usage: $0 is_good.c" >&2
+  echo "for example to compile: is_good.c" >&2
+  exit 1
+fi
+if [ "$#" -le 1 ] ; then
+  echo "Usage: $0 $1" >&2
+  echo " we can add more option for example '-D DEBUG=1' to have debug print, '-D HK' to have gtest like prompt, od '-g' to gbd" >&2
+  echo "for example: $0 $1 \"-D DEBUG=1 -D HK -g\""
+fi
+
+DIR_YTEST=$PWD/../../ytest_t
+SRC=../src
+
+gcc -o launch_is_good_c $1 -L$DIR_YTEST $2 -lytest -I$DIR_YTEST/include_ytest/include $SRC/list_t/list_t.c -I$SRC
+#gcc -o launch_is_good_c $1 $2 -lytest -I../include_ytest src/list_t/list_t.o src/set_theoric_t/set_theoric_t.o -I./src 
+
+export LD_LIBRARY_PATH=$DIR_YTEST/:LD_LIBRARY_PATH
+
+
+#gcc $1 src/ftest/ftest.c src/fmock/fmock.c src/tools_t/tools_t.c src/bar_progress/bar_progress.c src/list_t/list_t.c src/set_theoric_t/set_theoric_t.c -I./include $2 -o launch_is_good_c -lpthread 
diff --git a/onetensor/testDimension.c b/onetensor/testDimension.c
new file mode 100644
index 0000000..006031e
--- /dev/null
+++ b/onetensor/testDimension.c
@@ -0,0 +1,271 @@
+#include "../linktest/y_test_h.h"
+
+IMPLEMENTATION_FTEST()
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+// for sleep !
+#ifdef __linux__ 
+  #include <unistd.h>
+#elif _WIN32 
+  #include <windows.h>
+#endif
+
+#include "y_tensor_h.h"
+
+IMPLEMENTATION_DIMENSION()
+
+TEST(dimension0){
+
+  dimension *D = create_dim(5);
+
+  EXPECT_EQ(D->size,5);
+
+  free_dimension(D);
+}
+TEST(rank){
+  dimension *D=create_dim(4);
+  D->shape[0]=2;
+  D->shape[1]=3;
+  D->shape[2]=5;
+  D->shape[3]=6;
+
+  updateRankDim(D);
+  EXPECT_EQ(D->rank, 180);
+
+  free_dimension(D);
+}
+TEST(SplitDim){
+  dimension *D=create_dim(4);
+  D->shape[0]=2;
+  D->shape[1]=3;
+  D->shape[2]=5;
+  D->shape[3]=6;
+  
+  updateRankDim(D);
+  printDebug_dimension(D," D root");  
+
+  dimension *d_part1 = NULL,*d_part2=NULL;
+
+ split_dim_part(D, &d_part1, &d_part2, 1, 2); 
+
+  printDebug_dimension(d_part1," part1 from Root");  
+  printDebug_dimension(d_part2," part2 from Root");  
+
+  dimension *ad;
+
+  add_dimension(&ad,d_part1, d_part2);
+  printDebug_dimension(D," D root");  
+  printDebug_dimension(ad," ad ");  
+
+
+  free_dimension(D);
+  free_dimension(ad);
+  free(d_part1);
+  free(d_part2);
+}
+
+TEST(SplitDim_2){
+  dimension *D=create_dim(4);
+  D->shape[0]=2;
+  D->shape[1]=3;
+  D->shape[2]=5;
+  D->shape[3]=6;
+  
+  updateRankDim(D);
+  printDebug_dimension(D," D root");  
+
+  dimension *d_part1 = NULL,*d_part2=NULL;
+
+ split_dim_part(D, &d_part1, &d_part2, 3, 2); 
+
+  printDebug_dimension(d_part1," part1 from Root");  
+  printDebug_dimension(d_part2," part2 from Root");  
+
+  dimension *ad;
+
+  add_dimension(&ad,d_part1, d_part2);
+  printDebug_dimension(D," D root");  
+  printDebug_dimension(ad," ad ");  
+
+
+  free_dimension(D);
+  free_dimension(ad);
+  free(d_part1);
+  free(d_part2);
+}
+
+
+
+
+TEST(SubDim){
+  dimension *D=create_dim(4);
+  D->shape[0]=2;
+  D->shape[1]=3;
+  D->shape[2]=5;
+  D->shape[3]=6;
+
+  dimension *d_head2 = sub_minus_dim_head(D,2);
+  
+  
+  EXPECT_EQ(d_head2->rank, 2*3);
+
+  dimension *d_tail2 = sub_minus_dim_tail(D,2);
+  EXPECT_EQ(d_tail2->rank, 5*6);
+
+  free_dimension(D);
+  free(d_tail2);
+  free(d_head2);
+}
+
+TEST(SubDim){
+  dimension *D=create_dim(4);
+  D->shape[0]=2;
+  D->shape[1]=3;
+  D->shape[2]=5;
+  D->shape[3]=6;
+
+
+  dimension *d_head2 = sub_minus_dim_head(D,2);
+  
+  
+  EXPECT_EQ(d_head2->rank, 2*3);
+
+  dimension *d_tail2 = sub_minus_dim_tail(D,2);
+  EXPECT_EQ(d_tail2->rank, 5*6);
+
+  free_dimension(D);
+  free(d_tail2);
+  free(d_head2);
+}
+
+TEST(Coord_linear){
+  dimension *D=create_dim(4);
+  D->shape[0]=2;
+  D->shape[1]=3;
+  D->shape[2]=5;
+  D->shape[3]=6;
+
+  updateRankDim(D);
+
+  size_t line=255;
+  size_t *coord = CoordFromLin(line,D);
+
+  for(size_t i=0; i<D->size; ++i){
+    LOG("coo[%ld]=%ld\n",i,coord[i]);
+  }
+  
+  EXPECT_EQ(line, LineFromCoord(coord, D));  
+  free_dimension(D);
+  free(coord);
+}
+
+TEST(signedCoord_linear){
+  dimension *D=create_dim(4);
+  D->shape[0]=2;
+  D->shape[1]=3;
+  D->shape[2]=5;
+  D->shape[3]=6;
+
+  updateRankDim(D);
+
+  long line=-255;
+  long *coord = signedCoordFromLin(line,D);
+
+  for(size_t i=0; i<D->size; ++i){
+    LOG("coo[%ld]=%ld\n",i,coord[i]);
+  }
+  
+  EXPECT_EQ(line, signedLineFromCoord(coord, D));  
+  free_dimension(D);
+  free(coord);
+}
+
+TEST(signedCoord_linearSuccessif){
+  dimension *D=create_dim(3);
+  D->shape[0]=2;
+  D->shape[1]=3;
+  D->shape[2]=2;
+
+  updateRankDim(D);
+
+  for(long line=-4; line < 4; ++line){
+    long *coord = signedCoordFromLin(line,D);
+
+    for(size_t i=0; i<D->size; ++i){
+      LOG("coo[%ld]=%ld\n",i,coord[i]);
+    }
+  
+    EXPECT_EQ(line, signedLineFromCoord(coord, D));  
+    free(coord);
+  }
+    free_dimension(D);
+}
+
+TEST(sprint_dim){
+  dimension *D=create_dim(4);
+  D->shape[0]=2;
+  D->shape[1]=3;
+  D->shape[2]=5;
+  D->shape[3]=6;
+
+  updateRankDim(D);
+
+  char *dimSTR =NULL;
+  size_t nb=sprint_dimension(&dimSTR, D);
+
+  LOG(" nb char : %ld\n, dim print:\n%s\n",nb, dimSTR);
+
+  free_dimension(D);
+  free(dimSTR);
+}
+
+TEST(incrment_dim){
+  littleEndian=false;
+  dimension *D=create_dim(4);
+  D->shape[0]=2;
+  D->shape[1]=3;
+  D->shape[2]=5;
+  D->shape[3]=6;
+
+  updateRankDim(D);
+
+  char *dimSTR =NULL;
+  size_t nb=sprint_dimension(&dimSTR, D);
+
+  LOG(" nb char : %ld\n, dim print:\n%s\n",nb, dimSTR);
+
+  increment_dim_var(D);
+
+  nb=sprint_dimension(&dimSTR, D);
+
+  LOG(" nb char : %ld\n, dim print increment:\n%s\n",nb, dimSTR);
+
+  free_dimension(D);
+  free(dimSTR);
+}
+
+
+TEST(list_shape_in_dim){
+  list_shape_in_dim *l_p=NULL;
+
+  for(size_t i=1;i<5; ++i){
+    append_in_list_shape(&l_p, i);
+  }
+
+  dimension *dim=create_dim_from_list_shape(l_p);
+
+  printDebug_dimension(dim, "from l_p"); 
+}
+
+
+int main(int argc, char **argv){
+  
+
+  run_all_tests_args(argc, argv);
+
+  return 0;
+}
diff --git a/onetensor/y_tensor_h.h b/onetensor/y_tensor_h.h
new file mode 100644
index 0000000..8780d20
--- /dev/null
+++ b/onetensor/y_tensor_h.h
@@ -0,0 +1,789 @@
+#ifndef __TOOLS_T_C_H__
+#define __TOOLS_T_C_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <time.h>
+
+#include <sys/ioctl.h>
+
+
+/* to define DEBUG in gcc cli do: gcc -D DEBUG=1 or 0 if need!*/
+#ifndef DEBUG
+  #define DEBUG 0
+#endif
+
+
+/* F_OUT file (stream) to log*/
+#ifndef F_OUT
+  #define F_OUT stdout
+#endif
+/* F_ERR file (stream) to log*/
+#ifndef F_ERR
+  #define F_ERR stderr
+#endif
+
+/*
+#ifndef SECOND
+  #define SECOND 0
+#endif
+#ifndef NANOSECOND
+  #define NANOSECOND 0
+#endif
+
+double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start);
+double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start);
+long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);
+*/
+
+#if 1
+
+extern long int PRECISION_TYPE_FLOAT ;
+extern long int PRECISION_TYPE_DOUBLE ;
+extern long int PRECISION_TYPE_L_DOUBLE ;
+
+#endif
+
+
+/*void get_cursor_position(int *col, int *rows);*/
+
+#if DEBUG
+
+#define debug_print(fmt, ...) \
+  do { /*if (DEBUG)*/ fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); } while (0)
+
+#define PRINT_DEBUG_(fmt, ...) \
+  do { /*if (DEBUG)*/ fprintf(F_ERR, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); } while (0)
+
+#else
+#define debug_print(fmt, ...) {} 
+
+#define PRINT_DEBUG_(fmt, ...) {}
+
+#endif
+
+#define error_print(fmt, ...) \
+   fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); 
+
+#define PRINT_ERROR(fmt, ...) \
+   fprintf(F_ERR, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); 
+
+#define PRINT_LOC_T(fmt, ...) \
+   fprintf(F_OUT, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); 
+
+
+
+#define TYPE_CHAR char
+#define TYPE_U_CHAR unsigned char
+#define TYPE_INT int
+#define TYPE_U_INT unsigned int
+#define TYPE_L_INT long int
+#define TYPE_U_L_INT unsigned long int
+#define TYPE_SIZE_T size_t
+#define TYPE_FLOAT float
+#define TYPE_DOUBLE double
+#define TYPE_L_DOUBLE long double
+#define TYPE_STRING char*
+
+#define FREE(x)  { free((x)); (x) = NULL;} 
+
+#define FOREACH(array, size, function)\
+  for(size_t _ind = 0; _ind < size; ++_ind) function(array[_ind]);
+
+#define MIN(X, Y) (((Y) < (X)) ? (Y) : (X))
+#define MAX(X, Y) (((Y) > (X)) ? (Y) : (X))
+
+#define GENERATE_ALL(type)\
+  int COMPARE_N_##type(const void *,const    void*);\
+  void COPY_ARRAY_##type(type* dst, const type* src, size_t size);\
+  type MAX_ARRAY_##type(const  type *array, size_t size);\
+  size_t ARG_MAX_ARRAY_##type(const type *array, size_t size);\
+  type MIN_ARRAY_##type(const  type *array, size_t size);\
+  size_t ARG_MIN_ARRAY_##type(const  type *array, size_t size);\
+  TYPE_STRING type##_TO_STR(type var);\
+  
+
+GENERATE_ALL(TYPE_CHAR)
+GENERATE_ALL(TYPE_U_CHAR)
+GENERATE_ALL(TYPE_INT)
+GENERATE_ALL(TYPE_U_INT)
+GENERATE_ALL(TYPE_L_INT)
+GENERATE_ALL(TYPE_U_L_INT)
+GENERATE_ALL(TYPE_SIZE_T)
+GENERATE_ALL(TYPE_FLOAT)
+GENERATE_ALL(TYPE_DOUBLE)
+GENERATE_ALL(TYPE_L_DOUBLE)
+GENERATE_ALL(TYPE_STRING)
+
+/* strto_type */
+
+int strto_TYPE_INT(char *str, char **endptr);
+unsigned int strto_TYPE_U_INT(char *str, char **endptr);
+long int strto_TYPE_L_INT(char *str, char **endptr);
+unsigned long int strto_TYPE_U_L_INT(char *str, char **endptr);
+size_t strto_TYPE_SIZE_T(char *str, char **endptr);
+float strto_TYPE_FLOAT(char *str, char **endptr);
+double strto_TYPE_DOUBLE(char *str, char **endptr);
+long double strto_TYPE_L_DOUBLE(char *str, char **endptr);
+
+/*
+ * time calucl
+ */
+double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start);
+
+double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start);
+
+long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);
+
+
+#endif /*__TOOLS_T_C_H__*/
+
+
+
+#define IMPLEMENTATION_TOOLS()\
+\
+GEN_TO_STR_N(TYPE_CHAR,2,"%c")\
+GEN_TO_STR_N(TYPE_U_CHAR,2,"%c")\
+GEN_TO_STR_N(TYPE_INT,22,"%d")\
+GEN_TO_STR_N(TYPE_U_INT,22,"%u")\
+GEN_TO_STR_N(TYPE_L_INT,22,"%ld")\
+GEN_TO_STR_N(TYPE_U_L_INT,22,"%lu")\
+GEN_TO_STR_N(TYPE_SIZE_T,22,"%lu")\
+GEN_TO_STR_N(TYPE_FLOAT,128,"%.10f")\
+GEN_TO_STR_N(TYPE_DOUBLE,256,"%.30lf")\
+GEN_TO_STR_N(TYPE_L_DOUBLE,256,"%.30Lf")\
+\
+TYPE_STRING TYPE_STRING_TO_STR(TYPE_STRING var){\
+  return var;\
+}\
+\
+\
+long int PRECISION_TYPE_CHAR  = 1;\
+long int PRECISION_TYPE_U_CHAR  = 1;\
+long int PRECISION_TYPE_INT  = 1;\
+long int PRECISION_TYPE_U_INT  = 1;\
+long int PRECISION_TYPE_L_INT  = 1;\
+long int PRECISION_TYPE_U_L_INT  = 1;\
+long int PRECISION_TYPE_SIZE_T  = 1;\
+\
+long int PRECISION_TYPE_FLOAT  = 100000000;\
+long int PRECISION_TYPE_DOUBLE  = 100000000000;\
+long int PRECISION_TYPE_L_DOUBLE  = 100000000000000;\
+\
+\
+\
+\
+int \
+COMPARE_N_TYPE_STRING(const void *a,const  void* b)\
+{\
+  char **aa=(char**)a;\
+  char **bb=(char**)b;\
+  PRINT_DEBUG_("a=%s, b=%s\n",*aa, *bb);\
+  return strcmp(*aa,*bb);\
+}\
+\
+void COPY_ARRAY_TYPE_STRING(char** dst, const char** src, size_t size)\
+{\
+  for(size_t i = 0; i < size; ++i) strcpy(dst[i],src[i]);\
+}\
+\
+\
+GENERATE_FUNCTION_NUMERIC(TYPE_CHAR)\
+GENERATE_FUNCTION_NUMERIC(TYPE_U_CHAR)\
+GENERATE_FUNCTION_NUMERIC(TYPE_INT)\
+GENERATE_FUNCTION_NUMERIC(TYPE_U_INT)\
+GENERATE_FUNCTION_NUMERIC(TYPE_L_INT)\
+GENERATE_FUNCTION_NUMERIC(TYPE_U_L_INT)\
+GENERATE_FUNCTION_NUMERIC(TYPE_SIZE_T)\
+GENERATE_FUNCTION_NUMERIC(TYPE_FLOAT)\
+GENERATE_FUNCTION_NUMERIC(TYPE_DOUBLE)\
+GENERATE_FUNCTION_NUMERIC(TYPE_L_DOUBLE)\
+\
+GENERATE_FUNCTION_ALL(TYPE_CHAR)\
+GENERATE_FUNCTION_ALL(TYPE_U_CHAR)\
+GENERATE_FUNCTION_ALL(TYPE_INT)\
+GENERATE_FUNCTION_ALL(TYPE_U_INT)\
+GENERATE_FUNCTION_ALL(TYPE_L_INT)\
+GENERATE_FUNCTION_ALL(TYPE_U_L_INT)\
+GENERATE_FUNCTION_ALL(TYPE_SIZE_T)\
+GENERATE_FUNCTION_ALL(TYPE_FLOAT)\
+GENERATE_FUNCTION_ALL(TYPE_DOUBLE)\
+GENERATE_FUNCTION_ALL(TYPE_L_DOUBLE)\
+GENERATE_FUNCTION_ALL(TYPE_STRING)\
+\
+/* strto_type */\
+  \
+int strto_TYPE_INT(char *str, char **endptr){ \
+  return (int)strtol(str,endptr,10);\
+}\
+unsigned int strto_TYPE_U_INT(char *str, char **endptr){ \
+  return (unsigned int)strtoul(str,endptr,10);\
+}\
+long int strto_TYPE_L_INT(char *str, char **endptr){\
+  return strtol(str,endptr,10);\
+}\
+unsigned long int strto_TYPE_U_L_INT(char *str, char **endptr){\
+  return strtoul(str,endptr,10);\
+}\
+size_t strto_TYPE_SIZE_T(char *str, char **endptr){\
+  return strtoul(str,endptr,10);\
+}\
+float strto_TYPE_FLOAT(char *str, char **endptr){\
+  return strtof(str,endptr);\
+}\
+double strto_TYPE_DOUBLE(char *str, char **endptr){\
+  return strtod(str,endptr);\
+}\
+long double strto_TYPE_L_DOUBLE(char *str, char **endptr){\
+  return strtold(str,endptr);\
+}\
+\
+\
+/*\
+ * time section\
+ */\
+\
+double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start){\
+  /*PRINT_DEBUG_("\n\nstop.sec:%ld, start.sec:%ld, stop.nsec:%ld, start.nsec:%ld\n\n",  time_stop.tv_sec , time_start.tv_sec, time_stop.tv_nsec , time_start.tv_nsec);*/\
+  return (time_stop.tv_sec - time_start.tv_sec) + 1.0e-9 * (time_stop.tv_nsec - time_start.tv_nsec);\
+}\
+\
+double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start){\
+  /*PRINT_DEBUG_("\n\nstop.sec:%ld, start.sec:%ld, stop.nsec:%ld, start.nsec:%ld\n\n",  time_stop.tv_sec , time_start.tv_sec, time_stop.tv_nsec , time_start.tv_nsec);*/\
+  return 1.0e3 * (time_stop.tv_sec - time_start.tv_sec) + 1.0e-6 * (time_stop.tv_nsec - time_start.tv_nsec);\
+}\
+\
+long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start){\
+  /*PRINT_DEBUG_("\n\nstop.sec:%ld, start.sec:%ld, stop.nsec:%ld, start.nsec:%ld\n\n",  time_stop.tv_sec , time_start.tv_sec, time_stop.tv_nsec , time_start.tv_nsec);*/\
+  return 1.0e9 * (time_stop.tv_sec - time_start.tv_sec) + (time_stop.tv_nsec - time_start.tv_nsec);\
+}\
+\
+
+
+
+#ifndef __DIMENSION_T_H__ 
+#define __DIMENSION_T_H__
+
+#include "../list_t/list_t.h"
+
+struct dimension{
+  size_t rank;
+  size_t *shape;
+  size_t size;
+};
+
+
+
+extern bool littleEndian;
+
+bool isLessEqThan(long int a, long int b) ;
+bool isLessThan(long int a, long int b) ;
+bool isGreatEqThan(long int a, long int b)  ;
+bool isGreatThan(long int a, long int b)  ;
+long int incr(long int i) ;
+long int decr(long int i) ;
+
+
+typedef struct dimension dimension ;
+
+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);
+dimension* sub_dim_tail(dimension *t, size_t subdim);
+
+dimension* sub_copy_minus_dim_head(dimension *t, size_t minusSubdim);
+dimension* sub_copy_minus_dim_tail(dimension *t, size_t minusSubdim);
+dimension* sub_copy_dim_head(dimension *t, size_t sub_copydim);
+dimension* sub_copy_dim_tail(dimension *t, size_t sub_copydim);
+
+void split_dim_part(dimension *root, dimension **part_1, dimension **part_2, size_t pivotSplit, size_t rangeInPivot );
+
+void add_copy_dimension(dimension **d, dimension *d0, dimension *d1);
+void min_copy_dimension(dimension **d, dimension *d0, dimension *d1);
+
+void add_dimension(dimension **d, dimension *d0, dimension *d1);
+void min_dimension(dimension **d, dimension *d0, dimension *d1);
+
+void printDebug_dimension(dimension *d, char *msg);
+size_t sprint_dimension(char **dimContent, dimension *d);
+
+void updateRankDim(dimension *dim);
+
+size_t LineFromCoord(size_t *coo, dimension *dim);
+size_t* CoordFromLin(size_t line, dimension *dim);
+void vCoordFromLin(size_t *ret, size_t line, dimension *dim );
+
+long int signedLineFromCoord(long *coo, dimension *dim);
+long int* signedCoordFromLin(long line, dimension *dim);
+void signedvCoordFromLin(long *ret, long int line, dimension *dim );
+
+
+void increment_dim_var(dimension *d);
+void decrement_dim_var(dimension *d);
+
+struct list_shape_in_dim{
+  size_t index;
+  size_t shape;
+  struct list_shape_in_dim *next;
+};
+
+typedef struct list_shape_in_dim list_shape_in_dim;
+
+void append_in_list_shape(list_shape_in_dim **list_p, size_t shape);
+dimension * create_dim_from_list_shape( list_shape_in_dim *l_p);
+
+dimension * create_binary_dim(size_t dimension_size);
+
+void free_list_shape_in_dim(list_shape_in_dim *l_p);
+
+CREATE_HEADER_LIST(dimension)
+
+typedef dimension * ptr_DIMENSION;
+
+CREATE_HEADER_LIST(ptr_DIMENSION)
+GEN_HEAD_PTR_LIST(ptr_DIMENSION)
+
+/*int compare_dimension(dimension *d1, dimension *d2);*/
+
+#endif /* __DIMENSION_T_H__*/
+
+#ifndef min
+#define min(x,y) (((x)<(y))?(x):(y)) 
+#endif 
+
+#define IMPLEMENTATION_DIMENSION()\
+\
+bool littleEndian=true;\
+\
+bool isLessEqThan(long int a, long int b) { return a <= b; }\
+bool isLessThan(long int a, long int b) { return a < b; }\
+bool isGreatEqThan(long int a, long int b)  { return a >= b; }\
+bool isGreatThan(long int a, long int b)  { return a > b; }\
+long int incr(long int i) { return i + 1; }\
+long int decr(long int i) { return i - 1; }\
+\
+dimension* init_dim(size_t *t, size_t sz){\
+  dimension *d = malloc(sizeof(dimension));\
+  d->size=sz;\
+  d->shape=t;\
+  updateRankDim(d);\
+  return d;\
+}\
+\
+dimension* init_copy_dim(size_t *t, size_t sz){\
+  if (sz==0) return NULL;\
+  dimension *d = malloc(sizeof(dimension));\
+  d->shape=malloc(sz * sizeof(size_t));\
+  d->size = sz;\
+  for(size_t i=0; i<sz; ++i) d->shape[i]=t[i];\
+  updateRankDim(d);\
+  return d;\
+}\
+dimension *\
+create_dim(size_t sz){\
+  if (sz==0) return NULL;\
+  dimension *d = malloc(sizeof(dimension));\
+  d->shape=malloc(sz * sizeof(size_t));\
+  d->size = sz;\
+  return d;\
+}\
+\
+dimension* clone_dim(dimension *dim){\
+return init_copy_dim(dim->shape,dim->size);\
+}\
+\
+dimension *\
+create_reverse_dim(size_t sz){\
+  dimension *dim = create_dim(sz);\
+  for(size_t i=0;i<sz;++i) dim->shape[i]=sz-1-i;\
+  updateRankDim(dim);\
+  return dim;\
+}\
+\
+void free_dimension(dimension *d){\
+  if(d){\
+    free(d->shape);\
+    free(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->shape[i] != d1->shape[i]) return false;\
+\
+  return true;\
+}\
+\
+dimension* sub_copy_minus_dim_head(dimension *root, size_t minusSubdim){\
+  if(minusSubdim < (root->size)){\
+    dimension *d = init_copy_dim(root->shape, (root->size)-minusSubdim);\
+    updateRankDim(d);\
+    return d;\
+  }\
+  return NULL;\
+}\
+\
+dimension* sub_copy_minus_dim_tail(dimension *root, size_t minusSubdim){\
+  if(minusSubdim < (root->size)){\
+    dimension *d = init_copy_dim((root->shape)+minusSubdim, (root->size)-minusSubdim);\
+    updateRankDim(d);\
+    return d;\
+  }\
+  return NULL;\
+}\
+\
+dimension* sub_copy_dim_head(dimension *root, size_t subdim){\
+  if(subdim < (root->size)){\
+    dimension *d = init_copy_dim(root->shape, subdim);\
+    updateRankDim(d);\
+    return d;\
+  }\
+  return NULL;\
+}\
+\
+dimension* sub_copy_dim_tail(dimension *root, size_t subdim){\
+  if(subdim < (root->size)){\
+    dimension *d = init_copy_dim((root->shape)+(root->size - subdim), subdim);\
+    updateRankDim(d);\
+    return d;\
+  }\
+  return NULL;\
+}\
+\
+void add_copy_dimension(dimension **d, dimension *d0, dimension *d1) {\
+    (*d) = create_dim(d0->size + d1->size);\
+    for (size_t i = 0; i < d0->size; i++) (*d)->shape[i] = d0->shape[i];\
+    for (size_t i = 0; i < d1->size; i++) (*d)->shape[d0->size + i] = d1->shape[i];\
+    updateRankDim(*d);\
+}\
+\
+void min_copy_dimension(dimension **d, dimension *d0, dimension *d1) {\
+    size_t mindim = min(d0->size,d1->size) ;\
+    (*d)=create_dim(mindim);\
+\
+       for (size_t i = 0; i < mindim; i++) {\
+            if (d0->shape[i] > d1->shape[i]) (*d)->shape[i] = d1->shape[i];\
+            else (*d)->shape[i] = d0->shape[i];\
+        }\
+    updateRankDim(*d);\
+}\
+\
+\
+\
+\
+dimension* sub_minus_dim_head(dimension *root, size_t minusSubdim){\
+  if(minusSubdim < (root->size)){\
+    dimension *d = init_dim(root->shape, (root->size)-minusSubdim);\
+    updateRankDim(d);\
+    return d;\
+  }\
+  return NULL;\
+}\
+dimension* sub_minus_dim_tail(dimension *root, size_t minusSubdim){\
+  if(minusSubdim < (root->size)){\
+    dimension *d = init_dim((root->shape)+minusSubdim, (root->size)-minusSubdim);\
+    updateRankDim(d);\
+    return d;\
+  }\
+  return NULL;\
+}\
+dimension* sub_dim_head(dimension *root, size_t subdim){\
+  if(subdim < (root->size)){\
+    dimension *d = init_dim(root->shape, subdim);\
+    updateRankDim(d);\
+    return d;\
+  }\
+  return NULL;\
+}\
+dimension* sub_dim_tail(dimension *root, size_t subdim){\
+  if(subdim < (root->size)){\
+    dimension *d = init_dim((root->shape)+(root->size - subdim), subdim);\
+    updateRankDim(d);\
+    return d;\
+  }\
+  return NULL;\
+}\
+\
+/*\
+void split_dim_part(dimension *root, dimension **part_1, dimension **part_2, size_t sz_nb_minus_part ) */\
+void split_dim_part(dimension *root, dimension **part_1, dimension **part_2, size_t pivotSplit, size_t rangeInPivot ) {\
+  if(pivotSplit < root->size){\
+  if(rangeInPivot <  root->shape[pivotSplit]){\
+    /*size_t sz_part1= (root->rank * sz_nb_minus_part)/(root->shape[(root->size)-1]);*/\
+    /*printf("sz_part1 :%ld \n",sz_part1);*/\
+    *part_1 = init_copy_dim(root->shape, root->size);\
+    ((*part_1)->shape[pivotSplit]) -= rangeInPivot;\
+    updateRankDim(*part_1);\
+    /*if(sz_nb_minus_part <2)\
+      *part_2 = init_copy_dim((root->shape), root->size-1 );\
+    else{*/\
+      *part_2 = init_copy_dim((root->shape), root->size );\
+      (*part_2)->shape[pivotSplit] = rangeInPivot ;\
+    /*}*/\
+    updateRankDim(*part_2);\
+  }\
+  }\
+}\
+\
+void increment_dim_var(dimension *d){\
+  if(littleEndian){\
+    (d->shape[0])++;\
+  }\
+  else{\
+    (d->shape[d->size - 1])++;\
+  }\
+}\
+\
+\
+void decrement_dim_var(dimension *d){\
+  if(littleEndian){\
+    (d->shape[0])--;\
+  }\
+  else{\
+    (d->shape[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)->shape[i] = d0->shape[i];\
+    for (size_t i = 0; i < d1->size; i++) (*d)->shape[d0->size + i] = d1->shape[i];\
+    updateRankDim(*d);\
+}\
+\
+void min_dimension(dimension **d, dimension *d0, dimension *d1) {\
+    if (d0->size > d1->size) {\
+        *d = d1;\
+    }\
+    else if (d0->size < d1->size) {\
+        *d = d0;\
+    }\
+    else { /* d0->size = d1->size*/\
+        *d = d0;\
+        for (size_t i = 0; i < d0->size; i++) {\
+            if (d0->shape[i] > d1->shape[i]) (*d)->shape[i] = d1->shape[i];\
+        }\
+    }\
+    updateRankDim(*d);\
+}\
+\
+void printDebug_dimension(dimension *d,char *msg){\
+\
+  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->shape[i]);\
+  printf("] \n");\
+    /*printf("[%ld: %ld] |", i,d->shape[i]);*/\
+ /* if(littleEndian)\
+    printf("\nlittleEndian (true): the bigest index varies first, e.g:  [x0,x1,x2,...,xn] xn is the bigest index\n");\
+  else\
+    printf("\nlittleEndian (false): the lowest index varies first, e.g: [x0,x1,x2,...,xn] x0 is the lowest index\n");\
+*/\
+}\
+\
+size_t sprint_dimension(char **dimContent, dimension *d){\
+  if(*dimContent != NULL){\
+    free(*dimContent);\
+    *dimContent=NULL;\
+  }\
+  size_t nbch=6*d->size+40;\
+  *dimContent = malloc(nbch);\
+  /*printf("nbCh=%ld\n",nbch);*/\
+  char *val=NULL;\
+  size_t cur=0;\
+  char *dimSzCh="dim->size";\
+  for(size_t i=0; i<strlen(dimSzCh);++i)\
+    (*dimContent)[cur++]=dimSzCh[i];\
+  (*dimContent)[cur++]='=';\
+  val=TYPE_SIZE_T_TO_STR(d->size);\
+  for(size_t c=0;c<strlen(val);++c)\
+    (*dimContent)[cur++]=val[c];\
+  free(val); val = NULL;\
+  (*dimContent)[cur++]=' ';\
+  (*dimContent)[cur++]='/';\
+  (*dimContent)[cur++]=' ';\
+  char *dimRkCh="dim->rank";\
+  for(size_t i=0; i<strlen(dimRkCh);++i)\
+    (*dimContent)[cur++]=dimRkCh[i];\
+  (*dimContent)[cur++]='=';\
+  val=TYPE_SIZE_T_TO_STR(d->rank);\
+  for(size_t c=0;c<strlen(val);++c)\
+    (*dimContent)[cur++]=val[c];\
+  free(val); val = NULL;\
+  (*dimContent)[cur++]=' ';\
+  (*dimContent)[cur++]='\n';\
+  (*dimContent)[cur++]='[';\
+  for(size_t i=0; i<d->size;++i){\
+    (*dimContent)[cur++]=' ';\
+    val=TYPE_SIZE_T_TO_STR(d->shape[i]);\
+    for(size_t c=0;c<strlen(val);++c)\
+      (*dimContent)[cur++]=val[c];\
+    free(val); val = NULL;\
+    (*dimContent)[cur++]=',';\
+   \
+  }\
+  (*dimContent)[cur++]=']';\
+\
+  (*dimContent)[cur++]='\n';\
+  (*dimContent)[cur++]='\0';\
+\
+  return cur;\
+}\
+\
+void updateRankDim(dimension *dim){\
+  dim->rank=1;\
+  for(size_t i=0; i<dim->size; ++i)\
+    dim->rank *=dim->shape[i];\
+}\
+\
+/* signed  */\
+long int signedLineFromCoord(long int *coo, dimension *dim){\
+    long int begin = 0;\
+    long int end = dim->size - 1;\
+    long int (*iter)(long int); iter = &incr;\
+    bool (*cond)(long int, long int); cond = &isLessEqThan;\
+\
+    if (littleEndian) {\
+        begin = dim->size - 1; end = 0;\
+        iter = &decr; cond = &isGreatEqThan;\
+    }\
+\
+    long int pp = 1;\
+    long int sm = 0;\
+    for (long int i = begin; cond(i, end); i = iter(i)) {\
+        sm += (coo[i] * pp);\
+        pp *= dim->shape[i];\
+    }\
+    return sm;\
+\
+}\
+\
+void signedvCoordFromLin(long int *ret, long int line, dimension *dim ){\
+    \
+    long int begin = 0, end = dim->size - 1;\
+    long int (*iter)(long int) = incr;\
+    bool (*cond)(long int, long int) = isLessThan;\
+    if (littleEndian == false) {\
+        /*if (littleEndian) {*/\
+        begin = dim->size - 1; end = 0;\
+        iter = decr; cond = isGreatThan;\
+    }\
+    /*prlong intf("to coor begin = %d end = %d \n", begin, end);*/\
+\
+    long int sm = line;\
+    long int pp = dim->rank;\
+    for (long int i = begin; cond(i, end); i = iter(i)) {\
+        /*prlong intf(" i: %d ", i);*/\
+        pp /= dim->shape[i];\
+        ret[i] = sm / pp;\
+        sm %= pp;\
+        /*prlong intf("sm[%d] = %d , pp=%d ; ", i, sm, pp);*/\
+    }\
+    ret[end] = sm;\
+}\
+\
+long int* signedCoordFromLin(long int line, dimension *dim){\
+    long int *ret;\
+    ret=malloc(dim->size*sizeof(long int));\
+    signedvCoordFromLin(ret,line,dim);\
+    return ret;\
+}\
+\
+/* */\
+/* unsigned */\
+size_t LineFromCoord(size_t *coo, dimension *dim) {\
+  return (long)signedLineFromCoord((long*)coo,dim);\
+}\
+\
+void vCoordFromLin(size_t *ret, size_t line, dimension *dim ){\
+  signedvCoordFromLin((long*)ret, (long)line, dim);\
+}\
+\
+size_t* CoordFromLin(size_t line, dimension *dim){\
+  return (size_t*)signedCoordFromLin((long)line, dim);\
+}\
+\
+\
+/* */\
+\
+void append_in_list_shape(list_shape_in_dim **list_p, size_t shape){\
+    list_shape_in_dim *lis=malloc(sizeof(list_shape_in_dim));\
+    lis->shape=shape;\
+    lis->next=NULL;\
+  if(*list_p == NULL){\
+    lis->index=0;\
+    *list_p = lis;\
+  }\
+  else{\
+    list_shape_in_dim *tmp =*list_p;\
+    while(tmp->next) tmp=tmp->next;\
+    lis->index = tmp->index +1;\
+    tmp->next=lis;\
+  }\
+}\
+\
+dimension * create_dim_from_list_shape( list_shape_in_dim *l_p){\
+\
+  if(l_p){\
+    list_shape_in_dim *tmp =l_p;\
+    while(tmp->next) tmp=tmp->next;\
+    dimension *dim=create_dim(tmp->index + 1);\
+    (dim)->size = tmp->index + 1;\
+    tmp=l_p;\
+    while(tmp){\
+      (dim)->shape[tmp->index]=tmp->shape;\
+      tmp=tmp->next;\
+    }\
+    updateRankDim(dim);\
+    return dim;\
+  }\
+  return NULL;\
+}\
+\
+dimension * create_binary_dim(size_t dimension_size){\
+  dimension * dim = create_dim(dimension_size);\
+  for(size_t i=0; i<dimension_size; ++i)\
+    dim->shape[i]=2;\
+  updateRankDim(dim);\
+  return dim;\
+}\
+\
+\
+void free_list_shape_in_dim(list_shape_in_dim *l_p){\
+  list_shape_in_dim *tmp=l_p, *ttmp;\
+  while(tmp){\
+    ttmp = tmp;\
+    tmp = ttmp->next;\
+    free(ttmp);\
+  }\
+}\
+\
+IMPLEMENTATION_LIST(dimension)\
+\
+IMPLEMENTATION_LIST(ptr_DIMENSION)\
+GEN_FUNC_PTR_LIST_FREE(ptr_DIMENSION){\
+  dimension *pdim=(dimension*)arg;\
+  free_dimension(pdim);\
+  /*free(pdim);*/\
+}\
+\
+
+