sstat 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e6e9880e553f0f4cf295f5ba717219c3063c301
-  data.tar.gz: ca274efe4e242eacf1fcf1944c6347e04257f820
+  metadata.gz: 2f0ea54fb1319bd5702f17df6fc58c5ae6f67ddf
+  data.tar.gz: bf10d230f11b7bac1888d9eb77c661ed6c597ee1
 SHA512:
-  metadata.gz: 39236d35f65f4aa8aae3adaa84f246caf670a63627ba23b7e7f026f8c08650b9e0fd4cd0eefe82bca9f1818b92fe22f27a908b7618e6e6fa23f7608bcebaeac4
-  data.tar.gz: 9afca3077c5aedbc9ed93899fc4a02c5c6010ebdc01375e634a47feaee5634ae67edc2aab0407ed888abb3ff5d51b9cff7fb6adbf61164fce4a9b3ce5b6a8014
+  metadata.gz: 51fe68035f95e4ee76cff316190a74ba910a40b0586bfd1207055d238ab4c6ab3003a10723b5366f4dafc4a7f862562ee75275f70283a7a03895d144f63e89b2
+  data.tar.gz: dc192a0ce719ff00141f6578956aa12c619d7519548993665f8050b2e7defdc200120f20cc581a467d9d534e8c5f168553ab00512074ea824b7cedddc5581de2

data/ext/sstat/lib/survival/survival_kaplan_meier.h

@@ -11,6 +11,7 @@
  * @param censored censored information: positive -> censored; zero or negative -> uncensored
  * @return CENS_UC_NUM structure
  */
+ #define EXP 1e-12
 int censored_uncensred_each_time_range(double* time, int* censored, int size,  struct CENS_UC_NUM** cens_ucens_number)
 {
 	int i, count_at, uncensored_num_at, censored_num_at;
@@ -193,18 +194,30 @@ int kaplan_meier(double* time, int* censored, int size, curve* KM_curve)
 /**
  * @brief extend the KM curve based on the last 3 points
  */
-int KM_3p_extrapolation(struct CENS_UC_NUM** cens_uc_num, struct CENS_UC_NUM** updated_cens_uc_num, int sample_size)
+int KM_3p_extrapolation(struct CENS_UC_NUM** cens_uc_num, struct CENS_UC_NUM ** updated_cens_uc_num, int sample_size)
 {
-	double mean_last_uncensored = 0;
-	double mean_last_censored = 0;
+	int mean_last_uncensored = 0;
+	int mean_last_censored = 0;
 	double time_interval_mean = 0;
+	
 	int num_left = 0;
+	int num_left_copy = 0;
+
+	/*Track break point during pre-mapping */
+	int is_break_at_uncensored = 0;
+
+	/*Track break point during pre-mapping */
+	int is_break_at_censored = 0;
+
 	int used_sample_num = 0;
 	int extrapolation_size = 0;
 	int updated_cens_uc_num_size = 0;
 	int i;
 	int last_1_index = (*cens_uc_num)->size - 2;
 	int last_4_index = (*cens_uc_num)->size - 5;
+	int actual_updated_size = 0;
+	int count = 0;
+	int extra = 0;
 
 	/* calculate the total number (censored and uncensored) already used */
 	for(i = 0; i < (*cens_uc_num)->size; i ++)
@@ -216,6 +229,7 @@ int KM_3p_extrapolation(struct CENS_UC_NUM** cens_uc_num, struct CENS_UC_NUM** u
 	/* TODO should error check here */
 	num_left = sample_size - used_sample_num;
 
+	/*Calculate the mean for uncensored, censored and time interval */
 	for(i = 0; i < 3; i++)
 	{
 		/*
@@ -231,16 +245,68 @@ int KM_3p_extrapolation(struct CENS_UC_NUM** cens_uc_num, struct CENS_UC_NUM** u
 	}
 
 	time_interval_mean = (*cens_uc_num)->time[last_1_index] - (*cens_uc_num)->time[last_4_index];
-	mean_last_uncensored = mean_last_uncensored / 3;
-	mean_last_censored = mean_last_censored / 3;
+	mean_last_uncensored = (int)floor(mean_last_uncensored / 3);
+	mean_last_censored = (int)floor(mean_last_censored / 3);
+
 	time_interval_mean = time_interval_mean / 3;
 	
 	/* Calculate how many points we should extrapolate */
 	extrapolation_size = ceil((double)num_left / (mean_last_uncensored + mean_last_censored));
+
 	updated_cens_uc_num_size = (*cens_uc_num)->size + extrapolation_size;
 
-	check(alloc_CENS_UC_NUM(updated_cens_uc_num, updated_cens_uc_num_size) == 0, "Failed in allocating CENS_UC_NUM structure");
+	/*If both mean_last_uncensored and mean_last_censored are zero return copy cens_uc_num to updated_cens_uc_num */
+	if(mean_last_uncensored < EXP && mean_last_censored < EXP) {
+		check(alloc_CENS_UC_NUM(updated_cens_uc_num, (*cens_uc_num)->size) == 0, "Failed in allocating CENS_UC_NUM structure");
+		/* Create a copy for the original cens_uc_num struct */
+		for(i = 0; i < (*cens_uc_num)->size; i++)
+		{
+			(*updated_cens_uc_num)->censored[i] = (*cens_uc_num)->censored[i];
+			(*updated_cens_uc_num)->uncensored[i] = (*cens_uc_num)->uncensored[i];
+			(*updated_cens_uc_num)->time[i] = (*cens_uc_num)->time[i];
+		}
+		return 0;
+	}
+
+	num_left_copy = num_left;
+
+
+	/* Pre-mapping to find the actual extrapolation number */
+	while(num_left_copy >= 0) {
+		num_left_copy = num_left_copy - mean_last_uncensored;
+		count++;
+		if(num_left_copy >= 0) {
+			is_break_at_uncensored = 0;
+			extra = num_left_copy;
+		} else {
+			is_break_at_uncensored = 1;
+			break;
+		}
+
+		num_left_copy = num_left_copy - mean_last_censored;
+
+		if(num_left_copy > 0) {
+			is_break_at_censored = 0;
+			extra = num_left_copy;
+		} else {
+			is_break_at_censored = 1;
+			break;
+		}
+
+		if(num_left_copy == 0) {
+			is_break_at_uncensored = 0;
+			is_break_at_censored = 0;
+			break;
+		}
+	}
 
+	//printf("Actual size, number left: %i, %i %i, %i, \n", count, num_left, mean_last_uncensored, mean_last_censored);
+
+	actual_updated_size = (*cens_uc_num)->size + count;
+
+	check(alloc_CENS_UC_NUM(updated_cens_uc_num, actual_updated_size) == 0, "Failed in allocating CENS_UC_NUM structure");
+	
+	/* Create a copy for the original cens_uc_num struct */
 	for(i = 0; i < (*cens_uc_num)->size; i++)
 	{
 		(*updated_cens_uc_num)->censored[i] = (*cens_uc_num)->censored[i];
@@ -248,24 +314,25 @@ int KM_3p_extrapolation(struct CENS_UC_NUM** cens_uc_num, struct CENS_UC_NUM** u
 		(*updated_cens_uc_num)->time[i] = (*cens_uc_num)->time[i];
 	}
 
-	for(i = (*cens_uc_num)->size; i < ((*cens_uc_num)->size + extrapolation_size); i++)
-	{
+	for(i = (*cens_uc_num)->size; i < actual_updated_size; i++) {
 		(*updated_cens_uc_num)->time[i] = (*updated_cens_uc_num)->time[i-1] + time_interval_mean;
+		if(i == actual_updated_size -1) {
+
+			if(is_break_at_uncensored) {
+				(*updated_cens_uc_num)->uncensored[i] = extra;
+				(*updated_cens_uc_num)->censored[i] = 0;
+			} else if(is_break_at_censored) {
+				(*updated_cens_uc_num)->uncensored[i] = mean_last_uncensored;
+				(*updated_cens_uc_num)->censored[i] = extra;
+			} else {
+				(*updated_cens_uc_num)->uncensored[i] = mean_last_censored;
+				(*updated_cens_uc_num)->censored[i] = mean_last_uncensored;
+			}
 
-		if (mean_last_uncensored<num_left)
-			(*updated_cens_uc_num)->uncensored[i] = mean_last_uncensored;
-		else
-			(*updated_cens_uc_num)->uncensored[i] = num_left;
-
-		/* We update the num_left to make sure that the total number of samples in the extrapolation group cannot be larger than the total number of samples */
-		num_left = num_left - mean_last_uncensored;
-
-		if (mean_last_censored<num_left)
-			(*updated_cens_uc_num)->censored[i] =  mean_last_censored;
-		else
-			(*updated_cens_uc_num)->censored[i] =  num_left;
-
-		num_left = num_left - mean_last_censored;
+		} else {
+			(*updated_cens_uc_num)->uncensored[i] = mean_last_censored;
+			(*updated_cens_uc_num)->censored[i] =  mean_last_uncensored;
+		}
 	}
 
 	return 0;

data/ext/sstat/sstat.c

@@ -2,228 +2,239 @@
 
 static VALUE rb_percentile(VALUE self, VALUE array, VALUE target)
 {
-  int size = RARRAY_LEN(array);
-  int i;
-  double _target = NUM2DBL(target);
-  double _percentile;
-  double* c_array = (double *)malloc(sizeof(double) * size);
-
-  for (i = 0; i < size; i++) {
-    c_array[i] = NUM2DBL(rb_ary_entry(array, i));
-  }
-  _percentile = precentile(c_array, size, _target);
-  free(c_array);
-
-  return DBL2NUM(_percentile);
+    int size = RARRAY_LEN(array);
+    int i;
+    double _target = NUM2DBL(target);
+    double _percentile;
+    double* c_array = (double *)malloc(sizeof(double) * size);
+
+    for (i = 0; i < size; i++) {
+        c_array[i] = NUM2DBL(rb_ary_entry(array, i));
+    }
+    _percentile = precentile(c_array, size, _target);
+    free(c_array);
+
+    return DBL2NUM(_percentile);
 }
 
 static VALUE rb_percentile_index(VALUE self, VALUE array, VALUE target)
 {
-  int size = RARRAY_LEN(array);
-  int i;
-  double _target = NUM2DBL(target);
-  int _percentile_index;
-  double* c_array = (double *)malloc(sizeof(double) * size);
-
-  for (i = 0; i < size; i++) {
-    c_array[i] = NUM2DBL(rb_ary_entry(array, i));
-  }
-  _percentile_index = precentile_index(c_array, size, _target);
-  free(c_array);
-
-  return INT2NUM(_percentile_index);
+    int size = RARRAY_LEN(array);
+    int i;
+    double _target = NUM2DBL(target);
+    int _percentile_index;
+    double* c_array = (double *)malloc(sizeof(double) * size);
+
+    for (i = 0; i < size; i++) {
+        c_array[i] = NUM2DBL(rb_ary_entry(array, i));
+    }
+    _percentile_index = precentile_index(c_array, size, _target);
+    free(c_array);
+
+    return INT2NUM(_percentile_index);
 }
 
 static VALUE rb_index_less_equal(VALUE self, VALUE array, VALUE target)
 {
-  int size = RARRAY_LEN(array);
-  int i;
-  int _index;
-  double _target = NUM2DBL(target);
-  double* c_array = (double *)malloc(sizeof(double) * size);
-  for (i = 0; i < size; i++) {
-    c_array[i] = NUM2DBL(rb_ary_entry(array, i));
-  }
+    int size = RARRAY_LEN(array);
+    int i;
+    int _index;
+    double _target = NUM2DBL(target);
+    double* c_array = (double *)malloc(sizeof(double) * size);
+    for (i = 0; i < size; i++) {
+        c_array[i] = NUM2DBL(rb_ary_entry(array, i));
+    }
 
-  _index = index_less_equal(c_array, size, _target);
+    _index = index_less_equal(c_array, size, _target);
 
-  free(c_array);
+    free(c_array);
 
-  return INT2NUM(_index);
+    return INT2NUM(_index);
 }
 
 static VALUE rb_hist_mean(VALUE self, VALUE bin, VALUE range)
 {
-  int bin_size = RARRAY_LEN(bin);
-  int range_size = RARRAY_LEN(range);
-  int i;
-
-  if ((range_size - bin_size) != 1)
-    rb_raise(rb_eTypeError, "Size of range should be 1 larger than size of bin.");
-
-  double hmean = 0;
-  struct histogram* h = (struct histogram*)malloc(sizeof(struct histogram));
-  h->n = bin_size;
-  h->range = malloc(sizeof(double) * ( h->n + 1));
-  h->bin = malloc(sizeof(double) * (h->n));
-
-  for (i = 0; i < bin_size; i++) {
-    h->bin[i] = NUM2DBL(rb_ary_entry(bin, i));
-  }
-
-  for (i = 0; i < range_size; i++) {
-    h->range[i] = NUM2DBL(rb_ary_entry(range, i));
-  }
-
-  histogram_mean(h, &hmean);
-  free_histogram(h);
-  return DBL2NUM(hmean);
+    int bin_size = RARRAY_LEN(bin);
+    int range_size = RARRAY_LEN(range);
+    int i;
+
+    if ((range_size - bin_size) != 1)
+        rb_raise(rb_eTypeError, "Size of range should be 1 larger than size of bin.");
+
+    double hmean = 0;
+    struct histogram* h = (struct histogram*)malloc(sizeof(struct histogram));
+    h->n = bin_size;
+    h->range = malloc(sizeof(double) * ( h->n + 1));
+    h->bin = malloc(sizeof(double) * (h->n));
+
+    for (i = 0; i < bin_size; i++) {
+        h->bin[i] = NUM2DBL(rb_ary_entry(bin, i));
+    }
+
+    for (i = 0; i < range_size; i++) {
+        h->range[i] = NUM2DBL(rb_ary_entry(range, i));
+    }
+
+    histogram_mean(h, &hmean);
+    free_histogram(h);
+    return DBL2NUM(hmean);
 }
 
 static VALUE rb_hist_median(VALUE self, VALUE bin, VALUE range)
 {
-  int bin_size = RARRAY_LEN(bin);
-  int range_size = RARRAY_LEN(range);
-  int i;
-
-  if ((range_size - bin_size) != 1)
-    rb_raise(rb_eTypeError, "Size of range should be 1 larger than size of bin.");
-
-  double hmedian = 0;
-  struct histogram* h = (struct histogram*)malloc(sizeof(struct histogram));
-  h->n = bin_size;
-  h->range = malloc(sizeof(double) * ( h->n + 1));
-  h->bin = malloc(sizeof(double) * (h->n));
-
-  for (i = 0; i < bin_size; i++) {
-    h->bin[i] = NUM2DBL(rb_ary_entry(bin, i));
-  }
-
-  for (i = 0; i < range_size; i++) {
-    h->range[i] = NUM2DBL(rb_ary_entry(range, i));
-  }
-
-  histogram_median(h, &hmedian);
-  free_histogram(h);
-  return DBL2NUM(hmedian);
+    int bin_size = RARRAY_LEN(bin);
+    int range_size = RARRAY_LEN(range);
+    int i;
+
+    if ((range_size - bin_size) != 1)
+        rb_raise(rb_eTypeError, "Size of range should be 1 larger than size of bin.");
+
+    double hmedian = 0;
+    struct histogram* h = (struct histogram*)malloc(sizeof(struct histogram));
+    h->n = bin_size;
+    h->range = malloc(sizeof(double) * ( h->n + 1));
+    h->bin = malloc(sizeof(double) * (h->n));
+
+    for (i = 0; i < bin_size; i++) {
+        h->bin[i] = NUM2DBL(rb_ary_entry(bin, i));
+    }
+
+    for (i = 0; i < range_size; i++) {
+        h->range[i] = NUM2DBL(rb_ary_entry(range, i));
+    }
+
+    histogram_median(h, &hmedian);
+    free_histogram(h);
+    return DBL2NUM(hmedian);
 }
 
 static VALUE rb_kaplan_meier(VALUE self, VALUE time, VALUE censored)
 {
-  int size = RARRAY_LEN(time);
-  int i;
-  struct curve KM_curve;
-  int proc_status;
-  VALUE result;
-  double* _time = (double *)malloc(sizeof(double) * size);
-  int* _censored = (int *)malloc(sizeof(int) * size);
-  for (i = 0; i < size; i++) {
-    _time[i] = NUM2DBL(rb_ary_entry(time, i));
-
-    _censored[i] = NUM2INT(rb_ary_entry(censored, i));
-  }
-
-  proc_status = kaplan_meier(_time, _censored, size, &KM_curve);
-  if (proc_status == 0 )
-  {
-    VALUE KM_x = rb_ary_new2(KM_curve.size);
-    VALUE KM_y = rb_ary_new2(KM_curve.size);
-
-    for (i = 0; i < KM_curve.size; i++)
-    {
-      rb_ary_store(KM_x, i, DBL2NUM(KM_curve.point_array[i].x));
-      rb_ary_store(KM_y, i, DBL2NUM(KM_curve.point_array[i].y));
+    int size = RARRAY_LEN(time);
+    int i;
+    struct curve KM_curve;
+    int proc_status;
+    VALUE result;
+    double* _time = (double *)malloc(sizeof(double) * size);
+    int* _censored = (int *)malloc(sizeof(int) * size);
+    for (i = 0; i < size; i++) {
+        _time[i] = NUM2DBL(rb_ary_entry(time, i));
+
+        _censored[i] = NUM2INT(rb_ary_entry(censored, i));
     }
 
-    result = rb_hash_new();
+    proc_status = kaplan_meier(_time, _censored, size, &KM_curve);
+    if (proc_status == 0 )
+    {
+        VALUE KM_x = rb_ary_new2(KM_curve.size);
+        VALUE KM_y = rb_ary_new2(KM_curve.size);
+
+        for (i = 0; i < KM_curve.size; i++)
+        {
+            rb_ary_store(KM_x, i, DBL2NUM(KM_curve.point_array[i].x));
+            rb_ary_store(KM_y, i, DBL2NUM(KM_curve.point_array[i].y));
+        }
+
+        result = rb_hash_new();
 
-    rb_hash_aset(result, rb_str_new2("time"), KM_x);
-    rb_hash_aset(result, rb_str_new2("prob"), KM_y);
+        rb_hash_aset(result, rb_str_new2("time"), KM_x);
+        rb_hash_aset(result, rb_str_new2("prob"), KM_y);
 
-    free(_time);
-    free(_censored);
-    free(KM_curve.point_array);
-    return result;
-  } else {
-    return Qfalse;
-  }
+        free(_time);
+        free(_censored);
+        free(KM_curve.point_array);
+        return result;
+    } else {
+        return Qfalse;
+    }
 }
 
 static VALUE rb_kaplan_meier_3p_extraploation(VALUE self, VALUE time, VALUE censored)
 {
-  int size = RARRAY_LEN(time);
-  int i;
-  struct curve KM_curve;
-  int proc_status;
-  VALUE result;
-  double* _time = (double *)malloc(sizeof(double) * size);
-  int* _censored = (int *)malloc(sizeof(int) * size);
-  for (i = 0; i < size; i++) {
-    _time[i] = NUM2DBL(rb_ary_entry(time, i));
-
-    _censored[i] = NUM2INT(rb_ary_entry(censored, i));
-  }
-
-  proc_status = kaplan_meier_3p_extrapolation(_time, _censored, size, &KM_curve);
-  if (proc_status == 0 )
-  {
-        VALUE KM_x = rb_ary_new2(KM_curve.size);
-    VALUE KM_y = rb_ary_new2(KM_curve.size);
+    int size = RARRAY_LEN(time);
+    int i;
+    struct curve KM_curve;
+    int proc_status;
+    VALUE result;
+    double* _time = (double *)malloc(sizeof(double) * size);
+    int* _censored = (int *)malloc(sizeof(int) * size);
+    for (i = 0; i < size; i++) {
+        _time[i] = NUM2DBL(rb_ary_entry(time, i));
+
+        _censored[i] = NUM2INT(rb_ary_entry(censored, i));
+    }
 
-    for (i = 0; i < KM_curve.size; i++)
+    proc_status = kaplan_meier_3p_extrapolation(_time, _censored, size, &KM_curve);
+    if (proc_status == 0 )
     {
-      rb_ary_store(KM_x, i, DBL2NUM(KM_curve.point_array[i].x));
-      rb_ary_store(KM_y, i, DBL2NUM(KM_curve.point_array[i].y));
+                VALUE KM_x = rb_ary_new2(KM_curve.size);
+        VALUE KM_y = rb_ary_new2(KM_curve.size);
+
+        for (i = 0; i < KM_curve.size; i++)
+        {
+            rb_ary_store(KM_x, i, DBL2NUM(KM_curve.point_array[i].x));
+            rb_ary_store(KM_y, i, DBL2NUM(KM_curve.point_array[i].y));
+        }
+
+        result = rb_hash_new();
+
+        rb_hash_aset(result, rb_str_new2("time"), KM_x);
+        rb_hash_aset(result, rb_str_new2("prob"), KM_y);
+
+        free(_time);
+        free(_censored);
+        //free(KM_curve.point_array);
+        return result;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE rb_log_rank_test(VALUE self, VALUE _time_1, VALUE _cens_1, VALUE _time_2, VALUE _cens_2)
+{
+    int size_1 = RARRAY_LEN(_time_1);
+    int size_2 = RARRAY_LEN(_time_2);
+
+    int i;
+    double _Z;
+
+    double* time_1 = (double *)malloc(sizeof(double) * size_1);
+    double* time_2 = (double *)malloc(sizeof(double) * size_2);
+    int* cens_1 = (int *)malloc(sizeof(int) * size_1);
+    int* cens_2 = (int *)malloc(sizeof(int) * size_2);
+    for (i = 0; i < size_1; i++) {
+        time_1[i] = NUM2DBL(rb_ary_entry(_time_1, i));
+        cens_1[i] = NUM2INT(rb_ary_entry(_cens_1, i));
+    }
+
+    for (i = 0; i < size_2; i++) {
+        time_2[i] = NUM2DBL(rb_ary_entry(_time_2, i));
+        cens_2[i] = NUM2INT(rb_ary_entry(_cens_2, i));
     }
 
-    result = rb_hash_new();
+    _Z = log_rank_test(time_1, cens_1, time_2, cens_2, size_1, size_2);
 
-    rb_hash_aset(result, rb_str_new2("time"), KM_x);
-    rb_hash_aset(result, rb_str_new2("prob"), KM_y);
+    free(time_1);
+    free(time_2);
+    free(cens_1);
+    free(cens_2);
 
-    free(_time);
-    free(_censored);
-    //free(KM_curve.point_array);
-    return result;
-  } else {
-    return Qfalse;
-  }
+    return DBL2NUM(_Z);
 }
 
-static VALUE rb_log_rank_test(VALUE self, VALUE _time_1, VALUE _cens_1, VALUE _time_2, VALUE _cens_2)
+static VALUE rb_cdf_unormal_Q(VALUE self, VALUE x)
 {
-  int size_1 = RARRAY_LEN(_time_1);
-  int size_2 = RARRAY_LEN(_time_2);
-
-  int i;
-  double _Z;
-
-  double* time_1 = (double *)malloc(sizeof(double) * size_1);
-  double* time_2 = (double *)malloc(sizeof(double) * size_2);
-  int* cens_1 = (int *)malloc(sizeof(int) * size_1);
-  int* cens_2 = (int *)malloc(sizeof(int) * size_2);
-  for (i = 0; i < size_1; i++) {
-    time_1[i] = NUM2DBL(rb_ary_entry(_time_1, i));
-    cens_1[i] = NUM2INT(rb_ary_entry(_cens_1, i));
-  }
-
-  for (i = 0; i < size_2; i++) {
-    time_2[i] = NUM2DBL(rb_ary_entry(_time_2, i));
-    cens_2[i] = NUM2INT(rb_ary_entry(_cens_2, i));
-  }
-
-  _Z = log_rank_test(time_1, cens_1, time_2, cens_2, size_1, size_2);
-
-  free(time_1);
-  free(time_2);
-  free(cens_1);
-  free(cens_2);
-
-  return DBL2NUM(_Z);
+    double Q = cdf_ugaussian_Q(NUM2DBL(x));
+    return DBL2NUM(Q);
 }
 
-static VALUE rb_cdf_unormal_Q(VALUE self, VALUE x)
+static VALUE rb_dist_chi_square_Q(VALUE self, VALUE index, VALUE degree)
 {
-  double Q = cdf_ugaussian_Q(NUM2DBL(x));
-  return DBL2NUM(Q);
+    return 0;
+}
+
+static VALUE rb_dist_chi_square_P(VALUE self, VALUE index, VALUE degree)
+{
+    return 0;
+
 }