sstat 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: beee6865b0bc618d70c67be9c3f000089416b24e
-  data.tar.gz: 21761e26f6a5af3402d3adc1d12e4a2af33897ce
+  metadata.gz: 05e07132478ee73c200a313aa3c07cd4861216c3
+  data.tar.gz: 0fac54eb739c5c1a0799f405d25e44a37cb816f4
 SHA512:
-  metadata.gz: d994e68d96cdebf07f8a2da62c14329eb0c65f29cedcc3c5f71563f6af7de1b1f480e608fa1a575d7129122dbf7da5d5a42976aac4ff9f27ef111c741dbcb0f2
-  data.tar.gz: bbe5ab1b30dbaeee27995d678b2dcf64e8d5a0b456e263d12d8685464a95da119d4145deb431444a49c278b6846ad375e87e9c877ebdb63cb3a7d0b90d11bce3
+  metadata.gz: 0f3d87d88a4482fe56fe3f65bc20b182da4c536c45e607c9a5bea4d1656543662bc0990fd3545af90aa3e4b4fa589f1c751f7a2f2d1fa75578f2a5085980d5f8
+  data.tar.gz: 35d138ebf041f1b3e5735a8c325387e01a5e1eea43f07f833a4d2473fa5d33eb3b91ea448d61c85ce96c5cb61fff1295a58d3fbbaf4a1dee37019671ed9bef47

data/bin/#console#

@@ -0,0 +1,14 @@
+k
+
+REQUIREsdfasdfjjjkksadfkjsdfkjj "bundler/setup"
+require "simple_statistics"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/ext/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+$CFLAGS << ' -std=gnu99 -Wno-declaration-after-statement'
+
+create_makefile('sstat')

data/ext/lib/distribution.h

@@ -0,0 +1,274 @@
+#ifndef _SSTAT_DISTRIBUTION_UTILITY_H_
+#define _SSTAT_DISTRIBUTION_UTILITY_H_
+#include "type_def.h"
+static double
+get_del (double x, double rational)
+{
+double xsq = 0.0;
+double del = 0.0;
+double result = 0.0;
+ 
+xsq = floor (x * GAUSS_SCALE) / GAUSS_SCALE;
+del = (x - xsq) * (x + xsq);
+del *= 0.5;
+ 
+result = exp (-0.5 * xsq * xsq) * exp (-1.0 * del) * rational;
+ 
+return result;
+}
+ 
+/*
+ * Normal cdf for fabs(x) < 0.66291
+ */
+static double
+gauss_small (const double x)
+{
+unsigned int i;
+double result = 0.0;
+double xsq;
+double xnum;
+double xden;
+ 
+const double a[5] = {
+2.2352520354606839287,
+161.02823106855587881,
+1067.6894854603709582,
+18154.981253343561249,
+0.065682337918207449113
+};
+const double b[4] = {
+47.20258190468824187,
+976.09855173777669322,
+10260.932208618978205,
+45507.789335026729956
+};
+ 
+xsq = x * x;
+xnum = a[4] * xsq;
+xden = xsq;
+ 
+for (i = 0; i < 3; i++)
+{
+xnum = (xnum + a[i]) * xsq;
+xden = (xden + b[i]) * xsq;
+}
+ 
+result = x * (xnum + a[3]) / (xden + b[3]);
+ 
+return result;
+}
+ 
+/*
+ * Normal cdf for 0.66291 < fabs(x) < sqrt(32).
+ */
+static double
+gauss_medium (const double x)
+{
+unsigned int i;
+double temp = 0.0;
+double result = 0.0;
+double xnum;
+double xden;
+double absx;
+ 
+const double c[9] = {
+0.39894151208813466764,
+8.8831497943883759412,
+93.506656132177855979,
+597.27027639480026226,
+2494.5375852903726711,
+6848.1904505362823326,
+11602.651437647350124,
+9842.7148383839780218,
+1.0765576773720192317e-8
+};
+const double d[8] = {
+22.266688044328115691,
+235.38790178262499861,
+1519.377599407554805,
+6485.558298266760755,
+18615.571640885098091,
+34900.952721145977266,
+38912.003286093271411,
+19685.429676859990727
+};
+ 
+absx = fabs (x);
+ 
+xnum = c[8] * absx;
+xden = absx;
+ 
+for (i = 0; i < 7; i++)
+{
+xnum = (xnum + c[i]) * absx;
+xden = (xden + d[i]) * absx;
+}
+ 
+temp = (xnum + c[7]) / (xden + d[7]);
+ 
+result = get_del (x, temp);
+ 
+return result;
+}
+ 
+/*
+ * Normal cdf for
+ * {sqrt(32) < x < GAUSS_XUPPER} union { GAUSS_XLOWER < x < -sqrt(32) }.
+ */
+static double
+gauss_large (const double x)
+{
+int i;
+double result;
+double xsq;
+double temp;
+double xnum;
+double xden;
+double absx;
+ 
+const double p[6] = {
+0.21589853405795699,
+0.1274011611602473639,
+0.022235277870649807,
+0.001421619193227893466,
+2.9112874951168792e-5,
+0.02307344176494017303
+};
+const double q[5] = {
+1.28426009614491121,
+0.468238212480865118,
+0.0659881378689285515,
+0.00378239633202758244,
+7.29751555083966205e-5
+};
+ 
+absx = fabs (x);
+xsq = 1.0 / (x * x);
+xnum = p[5] * xsq;
+xden = xsq;
+ 
+for (i = 0; i < 4; i++)
+{
+xnum = (xnum + p[i]) * xsq;
+xden = (xden + q[i]) * xsq;
+}
+ 
+temp = xsq * (xnum + p[4]) / (xden + q[4]);
+temp = (M_1_SQRT2PI - temp) / absx;
+ 
+result = get_del (x, temp);
+ 
+return result;
+}
+ 
+double
+gsl_cdf_ugaussian_P (const double x)
+{
+double result;
+double absx = fabs (x);
+ 
+if (absx < GAUSS_EPSILON)
+{
+result = 0.5;
+return result;
+}
+else if (absx < 0.66291)
+{
+result = 0.5 + gauss_small (x);
+return result;
+}
+else if (absx < SQRT32)
+{
+result = gauss_medium (x);
+ 
+if (x > 0.0)
+{
+result = 1.0 - result;
+}
+ 
+return result;
+}
+else if (x > GAUSS_XUPPER)
+{
+result = 1.0;
+return result;
+}
+else if (x < GAUSS_XLOWER)
+{
+result = 0.0;
+return result;
+}
+else
+{
+result = gauss_large (x);
+ 
+if (x > 0.0)
+{
+result = 1.0 - result;
+}
+}
+ 
+return result;
+}
+
+double
+cdf_ugaussian_Q (const double x)
+{
+double result;
+double absx = fabs (x);
+ 
+if (absx < GAUSS_EPSILON)
+{
+result = 0.5;
+return result;
+}
+else if (absx < 0.66291)
+{
+result = gauss_small (x);
+ 
+if (x < 0.0)
+{
+result = fabs (result) + 0.5;
+}
+else
+{
+result = 0.5 - result;
+}
+ 
+return result;
+}
+else if (absx < SQRT32)
+{
+result = gauss_medium (x);
+ 
+if (x < 0.0)
+{
+result = 1.0 - result;
+}
+ 
+return result;
+}
+else if (x > -(GAUSS_XLOWER))
+{
+result = 0.0;
+return result;
+}
+else if (x < -(GAUSS_XUPPER))
+{
+result = 1.0;
+return result;
+}
+else
+{
+result = gauss_large (x);
+ 
+if (x < 0.0)
+{
+result = 1.0 - result;
+}
+ 
+}
+ 
+return result;
+}
+#endif

data/ext/lib/global_utility.h

@@ -0,0 +1,17 @@
+#ifndef _SSTAT_GLOBAL_UTILITY_H_
+#define _SSTAT_GLOBAL_UTILITY_H_
+#include <stdio.h>
+#include <stdlib.h>
+#include "type_def.h"
+
+int compare_double (const void * a, const void * b)
+{
+   return *((double*)a) > *((double*)b)? 1 : 0;
+}
+
+int point_compare_x (const void * a, const void * b)
+{
+	return ((struct point*)a)->x - ((struct point*)b)->x;
+}
+
+#endif

data/ext/lib/survival.h

@@ -0,0 +1,6 @@
+#ifndef _SURVIVAL_STAT_H_
+#define _SURVIVAL_STAT_H_
+
+#include "survival_func.h"
+
+#endif

data/ext/lib/survival_def.h

@@ -0,0 +1,47 @@
+#ifndef _SURVIVAL_STAT_DEF_H_
+#define _SURVIVAL_STAT_DEF_H_
+
+#include "type_def.h"
+
+/* Define survival stat data structure */
+typedef struct Group_N
+{
+	/* Time stands for the event time */
+	double* time;
+
+	/* How many people died at different event times */
+	int * uncensored;
+
+	/* How many people censored at different event times */
+	int * censored;
+
+	int size;
+
+} Group_N;
+
+void free_Group_N(struct Group_N* grp_n)
+{
+	if(grp_n->time != NULL)
+		free(grp_n->time);
+
+	if(grp_n->uncensored != NULL )
+		free(grp_n->uncensored);
+
+	if(grp_n->censored != NULL )
+		free(grp_n->censored);
+}
+
+void put_Group_N(struct Group_N * grp_n)
+{
+	int i;
+	puts("Start to print out Group N");
+	for( i = 0; i < grp_n->size; i++ )
+	{
+		printf("Time : %f -- Uncensored : %f -- Censored : %f \n", 
+			grp_n-> time[i],
+			grp_n-> uncensored[i],
+			grp_n-> censored[i]);
+	}
+}
+
+#endif

data/ext/lib/survival_func.h

@@ -0,0 +1,204 @@
+#ifndef _SURVIVAL_STAT_FUNC_H_
+#define _SURVIVAL_STAT_FUNC_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "survival_def.h"
+#include "survival_utility.h"
+
+double precentile(double* array, int size, double target_percentile)
+{
+	double percentage_each = 1.0 / size;
+	int i;
+	int count = 0;
+
+	for (i = 1; i <= size; i++)
+	{
+		if ( i * percentage_each < target_percentile )
+		{
+			count++;
+		} else
+		{
+			return array[count];
+		}
+	}
+
+	return array[size - 1];
+}
+
+int index_less_equal(double* array, int size, double target)
+{
+	int i;
+
+	for (i = 0; i < size; i++)
+	{
+		if (array[i] > target)
+			return i;
+	}
+
+	return i;
+}
+
+double log_rank_test(double* time_1, int* censored_1, double* time_2, int* censored_2, int size_1, int size_2)
+{
+	int i, time_pnt_size;
+	int index;
+
+	array merged_time_pnts = merge_two_array(time_1, size_1, time_2, size_2);
+	array merged_uniq_time_pnts = create_sorted_unique_array(merged_time_pnts.D_ptr, merged_time_pnts.size);
+
+	//The lengths of Group_N_1 and Group_N_2 are not expected to be same. Step 1. create unique time array which inlcude time points for both
+	Group_N Group_N_1 = group_N_given_range(time_1, censored_1, size_1, merged_uniq_time_pnts.D_ptr, merged_uniq_time_pnts.size);
+	Group_N Group_N_2 = group_N_given_range(time_2, censored_2, size_2, merged_uniq_time_pnts.D_ptr, merged_uniq_time_pnts.size);
+
+	double Z = 0;
+	double V_i_sum = 0;
+
+	Group_N combined_Group_N_1;
+	Group_N combined_Group_N_2;
+
+	combined_Group_N_1.uncensored = (int*) malloc(merged_uniq_time_pnts.size * sizeof(int));
+	combined_Group_N_1.censored = (int*) malloc(merged_uniq_time_pnts.size * sizeof(int));
+
+	combined_Group_N_2.uncensored = (int*) malloc(merged_uniq_time_pnts.size * sizeof(int));
+	combined_Group_N_2.censored = (int*) malloc(merged_uniq_time_pnts.size * sizeof(int));
+
+	//CAUTION: DO NOT SET TIME ARRAY HEERE, USE merged_uniq_time_pnts INSTEAD
+	combined_Group_N_1.time = NULL;
+	combined_Group_N_2.time = NULL;
+
+	time_pnt_size = merged_uniq_time_pnts.size;
+
+	int* N1_at_risk = (int*) malloc(time_pnt_size * sizeof(int));
+	int* N2_at_risk = (int*) malloc(time_pnt_size * sizeof(int));
+	int* N_i = (int*) malloc(time_pnt_size * sizeof(int));
+	int* O_i = (int*) malloc(time_pnt_size * sizeof(int));
+
+	double* E_i = (double*) malloc(time_pnt_size * sizeof(double));
+	double* V_i = (double*) malloc(time_pnt_size * sizeof(double));
+
+	//update at_risk for 1 and 2 based on combined_time_arr.
+	for (i = 0; i < time_pnt_size; ++i)
+	{
+		index = find_first_index_has(Group_N_1.time, Group_N_1.size, merged_uniq_time_pnts.D_ptr[i]);
+		if (index >= 0)
+		{
+			combined_Group_N_1.uncensored[i] = Group_N_1.uncensored[index];
+			combined_Group_N_1.censored[i] = Group_N_1.censored[index];
+		} else {
+
+			combined_Group_N_1.uncensored[i] = 0;
+			combined_Group_N_1.censored[i] = 0;
+		}
+	}
+
+	for (i = 0; i < time_pnt_size; ++i)
+	{
+		index = find_first_index_has(Group_N_2.time, Group_N_2.size, merged_uniq_time_pnts.D_ptr[i]);
+
+		if (index >= 0)
+		{
+			combined_Group_N_2.uncensored[i] = Group_N_2.uncensored[index];
+			combined_Group_N_2.censored[i] = Group_N_2.censored[index];
+		} else {
+			combined_Group_N_2.uncensored[i] = 0;
+			combined_Group_N_2.censored[i] = 0;
+		}
+	}
+
+	N1_at_risk[0] =  size_1 - combined_Group_N_1.censored[0];
+	N2_at_risk[0] =  size_2 - combined_Group_N_2.censored[0];
+
+	for (i = 1; i < time_pnt_size; ++i)
+	{
+		N1_at_risk[i] = N1_at_risk[i - 1] - combined_Group_N_1.uncensored[i - 1] - combined_Group_N_1.censored[i];
+		N2_at_risk[i] = N2_at_risk[i - 1] - combined_Group_N_2.uncensored[i - 1] - combined_Group_N_2.censored[i];
+
+	}
+
+	for (i = 0; i < time_pnt_size; ++i)
+	{
+		N_i[i] = N1_at_risk[i] + N2_at_risk[i];
+		O_i[i] = (combined_Group_N_1.uncensored[i] + combined_Group_N_2.uncensored[i]);
+		E_i[i] = 1.0 * N1_at_risk[i] * O_i[i] / N_i[i];
+
+		if (N_i[i] > 1)
+		{
+			V_i[i] = 1.0 * O_i[i]
+			         * (1.0 * N1_at_risk[i] / N_i[i])
+			         * (1 - 1.0 * N1_at_risk[i] / N_i[i])
+			         * (N_i[i] - O_i[i]) / (N_i[i] - 1);
+			         
+			V_i_sum += V_i[i];
+		}
+
+		Z += (combined_Group_N_1.uncensored[i] - E_i[i]);
+	}
+
+	Z = Z / sqrt(V_i_sum);
+	free(Group_N_1.uncensored);
+	free(Group_N_1.censored);
+	free(Group_N_2.uncensored);
+	free(Group_N_2.censored);
+	free(merged_time_pnts.D_ptr);
+	free(merged_uniq_time_pnts.D_ptr);
+	free(N1_at_risk);
+	free(N2_at_risk);
+	free(N_i);
+	free(O_i);
+	free(E_i);
+	free(V_i);
+
+	return Z;
+}
+
+/*
+* This function does not provide a normal kaplan meier curve. A extension based on the last 3 points is applied during the calculation of KM curve
+*/
+int kaplan_meier_3p_extrapolation(double* time, int* censored, int size)
+{
+
+	Group_N at_risk = group_N_self_range(time, censored, size);
+	printf("XXXXXXXXXXXXXXXXXXX  \n");
+	puts_Group_N(&at_risk);
+	free_Group_N(at_risk);
+
+	return 0;
+}
+
+struct curve kaplan_meier(double* time, int* censored, int size)
+{
+
+	int i, N;
+
+	Group_N at_risk = group_N_self_range(time, censored, size);
+
+	N = size;
+
+	struct point* KM = (struct point*) malloc(at_risk.size * sizeof(struct point));
+
+	for (i = 0; i < at_risk.size; i++)
+	{
+		if (i > 0)
+		{
+			N = (N - at_risk.uncensored[i - 1] - at_risk.censored[i - 1]);
+			KM[i].x = at_risk.time[i];
+			KM[i].y = 1.0 * (N - at_risk.uncensored[i] - at_risk.censored[i]) / (N - at_risk.censored[i]) * KM[i - 1].y;
+		} else {
+			KM[0].x = at_risk.time[i];
+			KM[0].y = 1.0 * (N - at_risk.uncensored[0] - at_risk.censored[0]) / (N - at_risk.censored[0]);
+		}
+	}
+
+	curve KM_curve;
+	KM_curve.point_array = KM;
+	KM_curve.size = at_risk.size;
+
+	free(at_risk.uncensored);
+	free(at_risk.censored);
+	free(at_risk.time);
+
+	return KM_curve;
+}
+
+#endif