add new sub functions def and rename old sub func to sub_minus in dimension and tensor reps

dimension_t/src/dimension_t/dimension_t.c

@@ -19,7 +19,7 @@ create_dim(size_t sz){
   return CREATE_PERMUTATION_TYPE_SIZE_T(sz);
 }
 
-dimension* sub_dim_head(dimension *root, size_t minusSubdim){
+dimension* sub_minus_dim_head(dimension *root, size_t minusSubdim){
   if(minusSubdim < (root->size)){
     dimension *d = INIT_PERMUTATION_TYPE_SIZE_T(root->perm, (root->size)-minusSubdim);
     updateRankDim(d);
@@ -27,7 +27,7 @@ dimension* sub_dim_head(dimension *root, size_t minusSubdim){
   }
   return NULL;
 }
-dimension* sub_dim_tail(dimension *root, size_t minusSubdim){
+dimension* sub_minus_dim_tail(dimension *root, size_t minusSubdim){
   if(minusSubdim < (root->size)){
     dimension *d = INIT_PERMUTATION_TYPE_SIZE_T((root->perm)+minusSubdim, (root->size)-minusSubdim);
     updateRankDim(d);
@@ -35,6 +35,22 @@ dimension* sub_dim_tail(dimension *root, size_t minusSubdim){
   }
   return NULL;
 }
+dimension* sub_dim_head(dimension *root, size_t subdim){
+  if(subdim < (root->size)){
+    dimension *d = INIT_PERMUTATION_TYPE_SIZE_T(root->perm, subdim);
+    updateRankDim(d);
+    return d;
+  }
+  return NULL;
+}
+dimension* sub_dim_tail(dimension *root, size_t subdim){
+  if(subdim < (root->size)){
+    dimension *d = INIT_PERMUTATION_TYPE_SIZE_T((root->perm)+(root->size - subdim), subdim);
+    updateRankDim(d);
+    return d;
+  }
+  return NULL;
+}
 void add_dimension(dimension **d, dimension *d0, dimension *d1) {
     (*d) = create_dim(d0->size + d1->size);
     //printf("d size : %ld\n",(*d)->size);

dimension_t/src/dimension_t/dimension_t.h

@@ -10,8 +10,10 @@ typedef struct PERMUTATION_TYPE_SIZE_T dimension ;
 dimension * create_dim(size_t size);
 dimension* init_dim(size_t *t, size_t sz);
 
-dimension* sub_dim_head(dimension *t, size_t minusSubdim);
-dimension* sub_dim_tail(dimension *t, size_t minusSubdim);
+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);
 
 void add_dimension(dimension **d, dimension *d0, dimension *d1);
 void min_dimension(dimension **d, dimension *d0, dimension *d1);

dimension_t/test/is_good.c

@@ -41,12 +41,12 @@ TEST(SubDim){
   D->perm[2]=5;
   D->perm[3]=6;
 
-  dimension *d_head2 = sub_dim_head(D,2);
+  dimension *d_head2 = sub_minus_dim_head(D,2);
   
   
   EXPECT_EQ(d_head2->rank, 2*3);
 
-  dimension *d_tail2 = sub_dim_tail(D,2);
+  dimension *d_tail2 = sub_minus_dim_tail(D,2);
   EXPECT_EQ(d_tail2->rank, 5*6);
 
 }
@@ -59,12 +59,12 @@ TEST(SubDim){
   D->perm[3]=6;
 
 
-  dimension *d_head2 = sub_dim_head(D,2);
+  dimension *d_head2 = sub_minus_dim_head(D,2);
   
   
   EXPECT_EQ(d_head2->rank, 2*3);
 
-  dimension *d_tail2 = sub_dim_tail(D,2);
+  dimension *d_tail2 = sub_minus_dim_tail(D,2);
   EXPECT_EQ(d_tail2->rank, 5*6);
 
 }

tensor_t/src/tensor_t/tensor_t.c

@@ -33,11 +33,11 @@ void printArraySzt(size_t *a, size_t sz,char *msg){
     return r_tens;\
   }\
 \
-  tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\
+  tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\
     dimension *rdim= rootens->dim;\
-    dimension *dS_t = sub_dim_tail(rdim,rdim->size - minuSubdim);\
+    dimension *dS_t = sub_minus_dim_tail(rdim,rdim->size - minuSubdim);\
     if(rankInDim < dS_t->rank){\
-      dimension *dS_h = sub_dim_head(rdim,minuSubdim);\
+      dimension *dS_h = sub_minus_dim_head(rdim,minuSubdim);\
       tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_h;\
       /*ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;*/\
@@ -57,11 +57,59 @@ void printArraySzt(size_t *a, size_t sz,char *msg){
     return NULL;\
   }\
   \
-  tensor_##type * sub_tensor_tail_##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){\
     dimension *rdim= rootens->dim;\
-    dimension *dS_h = sub_dim_head(rdim,rdim->size - minuSubdim);\
+    dimension *dS_h = sub_minus_dim_head(rdim,rdim->size - minuSubdim);\
     if(rankInDim < dS_h->rank){\
-      dimension *dS_t = sub_dim_tail(rdim,minuSubdim);\
+      dimension *dS_t = sub_minus_dim_tail(rdim,minuSubdim);\
+      tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
+      ret_ens->dim = dS_t;\
+      if(endian==false){\
+        ret_ens->x = malloc(sizeof(type)*dS_t->rank);\
+        for(size_t i=0; i<dS_t->rank; ++i){\
+          ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\
+          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
+          \
+        }\
+      }else{\
+        ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;\
+      \
+      }\
+      return ret_ens;\
+    }\
+    return NULL;\
+  }\
+  \
+  tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim){\
+    /*return sub_minus_tensor_head_##type(rootens,rootens->dim->size - subdim, rankInDim);*/\
+    dimension *rdim= rootens->dim;\
+    dimension *dS_t = sub_dim_tail(rdim,rdim->size - subdim);\
+    if(rankInDim < dS_t->rank){\
+      dimension *dS_h = sub_dim_head(rdim,subdim);\
+      tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
+      ret_ens->dim = dS_h;\
+      /*ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;*/\
+      if(endian){\
+        ret_ens->x = malloc(sizeof(type)*dS_h->rank);\
+        for(size_t i=0; i<dS_h->rank; ++i){\
+          ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\
+          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
+          \
+        }\
+      }else{\
+        ret_ens->x = (rootens->x)+rankInDim*dS_h->rank;\
+      \
+      }\
+      return ret_ens;\
+    }\
+    return NULL;\
+  }\
+  tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim){ \
+    /*return sub_minus_tensor_tail_##type(rootens,rootens->dim->size - subdim, rankInDim);*/\
+    dimension *rdim= rootens->dim;\
+    dimension *dS_h = sub_dim_head(rdim,rdim->size - subdim);\
+    if(rankInDim < dS_h->rank){\
+      dimension *dS_t = sub_dim_tail(rdim,subdim);\
       tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_t;\
       if(endian==false){\

tensor_t/src/tensor_t/tensor_t.h

@@ -12,8 +12,10 @@ struct tensor_##type{\
 };\
 typedef struct tensor_##type tensor_##type;\
 tensor_##type * CREATE_TENSOR_##type(dimension *dim); \
-tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
-tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
+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); \
+tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim); \
+tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim); \
 void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1); \
 void tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1); \
 void tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \

tensor_t/test/is_good.c

@@ -51,6 +51,100 @@ void print_tensor_double(tensor_TYPE_DOUBLE *M, char *msg){
     LOG("%s","\n");
 }
 
+TEST(tensorMinusSubhead_ ){
+  dimension *d0=create_dim(3);
+
+  d0->perm[0]=4;
+  d0->perm[1]=3;
+  d0->perm[2]=5;
+  
+
+  updateRankDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+
+  endian=false;
+  size_t rnkId = 1;
+  tensor_TYPE_FLOAT *s2h = sub_minus_tensor_head_TYPE_FLOAT(M0,1,rnkId);
+
+  print_tensor_float(M0, "M0 for sub");
+  print_tensor_float(s2h, "sub s2h of M0");
+
+  printDebug_dimension(M0->dim," M0 dimension  ");
+  printDebug_dimension(s2h->dim," s2h dimension  ");
+ //EXPECT_ARRAY_EQ_TYPE_FLOAT(M0->x,s2h->dim->rank,s2h->x,s2h->dim->rank);
+ 
+  for(size_t i1=0; i1<d0->perm[1];++i1){
+    for(size_t i0=0; i0<d0->perm[0];++i0){
+      printf("EXPECT_EQ_TYPE_FLOAT c0[%ld](%ld,%ld,%ld) : s[%ld](%ld,%ld) \n",LineFromCoord((size_t[]){i0,i1,rnkId},M0->dim),rnkId,i0,i1,LineFromCoord((size_t[]){i0,i1},s2h->dim),i0,i1);
+      EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((size_t[]){i0,i1,rnkId},M0->dim)],s2h->x[LineFromCoord((size_t[]){i0,i1},s2h->dim)]);
+    }  
+  }
+}
+
+TEST(tensorMinusSubtail ){
+  dimension *d0=create_dim(3);
+
+  d0->perm[0]=4;
+  d0->perm[1]=3;
+  d0->perm[2]=5;
+  
+
+  updateRankDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+
+
+  tensor_TYPE_FLOAT *s1t = sub_minus_tensor_tail_TYPE_FLOAT(M0,1,5);
+
+  print_tensor_float(M0, "M0 for sub");
+  print_tensor_float(s1t, "sub s2t of M0 from 5");
+
+}
+
+
+TEST(tensorMinusSubtail ){
+  dimension *d0=create_dim(3);
+
+  d0->perm[0]=4;
+  d0->perm[1]=3;
+  d0->perm[2]=5;
+  
+
+  updateRankDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+
+  //endian=false;
+  size_t rnkId=3;
+  tensor_TYPE_FLOAT *s2t = sub_minus_tensor_tail_TYPE_FLOAT(M0,1,rnkId);
+
+
+
+  print_tensor_float(M0, "M0 for sub");
+  print_tensor_float(s2t, "sub s2t of M0 from 3");
+
+  for(size_t i1=0; i1<d0->perm[1];++i1){
+    for(size_t i2=0; i2<d0->perm[2];++i2){
+      printf("EXPECT_EQ_TYPE_FLOAT c0[%ld](%ld,%ld,%ld) : s[%ld](%ld,%ld) \n",LineFromCoord((size_t[]){rnkId,i1,i2},M0->dim),rnkId,i1,i2,LineFromCoord((size_t[]){i1,i2},s2t->dim),i1,i2);
+      EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((size_t[]){rnkId,i1,i2},M0->dim)],s2t->x[LineFromCoord((size_t[]){i1,i2},s2t->dim)]);
+    }  
+  }
+
+}
+
 TEST(tensorSubhead_ ){
   dimension *d0=create_dim(3);
 
@@ -69,7 +163,7 @@ TEST(tensorSubhead_ ){
 
   endian=false;
   size_t rnkId = 1;
-  tensor_TYPE_FLOAT *s2h = sub_tensor_head_TYPE_FLOAT(M0,1,rnkId);
+  tensor_TYPE_FLOAT *s2h = sub_tensor_head_TYPE_FLOAT(M0,2,rnkId);
 
   print_tensor_float(M0, "M0 for sub");
   print_tensor_float(s2h, "sub s2h of M0");
@@ -85,8 +179,6 @@ TEST(tensorSubhead_ ){
     }  
   }
 }
-
-
 TEST(tensorSubtail ){
   dimension *d0=create_dim(3);
 
@@ -104,7 +196,7 @@ TEST(tensorSubtail ){
   for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
 
 
-  tensor_TYPE_FLOAT *s1t = sub_tensor_tail_TYPE_FLOAT(M0,1,5);
+  tensor_TYPE_FLOAT *s1t = sub_tensor_tail_TYPE_FLOAT(M0,2,5);
 
   print_tensor_float(M0, "M0 for sub");
   print_tensor_float(s1t, "sub s2t of M0 from 5");
@@ -130,7 +222,7 @@ TEST(tensorSubtail ){
 
   //endian=false;
   size_t rnkId=3;
-  tensor_TYPE_FLOAT *s2t = sub_tensor_tail_TYPE_FLOAT(M0,1,rnkId);
+  tensor_TYPE_FLOAT *s2t = sub_tensor_tail_TYPE_FLOAT(M0,2,rnkId);