sstat 0.0.10 → 0.0.11

data/ext/lib/survival_func.h

@@ -1,204 +0,0 @@
-#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);
-	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

data/ext/lib/survival_utility.h

@@ -1,293 +0,0 @@
-#ifndef _SURVIVAL_STAT_UTILITY_H_
-#define _SURVIVAL_STAT_UTILITy_H_
-
-#include <stdio.h>
-#include <stdlib.h>
-#include "global_utility.h"
-#include "survival_def.h"
-#include "type_def.h"
-
-struct array create_sorted_unique_array(double* array, int size)
-{
-	struct array arr;
-	int i;
-	/* For performance, we have not used memset here. This might be risky */
-	arr.D_ptr = NULL;
-	int count;
-
-	qsort(array, size, sizeof(double), &compare_double);
-
-	count = 1;
-	
-	//calcualte number of unique
-	for(i = 1; i < size; ++i)
-	{
-		if(array[i] != array[i-1])
-		{
-			count++;
-		}
-	}
-
-	double * unique_arr = (double *) malloc(count * sizeof(double));
-
-	//assign unique elements
-	count = 1;
-	unique_arr[0] = array[0];
-	for(i = 1; i < size; ++i)
-	{
-		if(array[i] != array[i-1])
-		{
-			unique_arr[count] = array[i];
-			count++;
-		}
-	}
-
-	arr.D_ptr = unique_arr;
-	arr.size = count;
-
-	return arr;
-}
-
-array merge_two_array(double* array_1, int size_1, double* array_2, int size_2)
-{
-	int i;
-	struct array arr;
-
-	//To speed up, choose to do not memset arr.
-	arr.D_ptr = NULL;
-
-	int total_size = size_1 + size_2;
-	double * merged_array = (double *) malloc(total_size * sizeof(double));
-	for(i = 0; i < size_1; i++)
-	{
-		merged_array[i] = array_1[i];
-	}
-
-	for( i = 0; i < size_2; i++)
-	{
-		merged_array[i + size_1] = array_2[i];
-	}
-
-	arr.D_ptr = merged_array;
-	arr.size = total_size;
-
-	return arr;
-}
-
-int find_first_index_has(double* arr, int size, double value)
-{
-	int i;
-	for(i = 0; i < size; i++)
-	{
-		if(fabs(arr[i] - value) < EPSILON)
-		{
-			return i;
-		}
-	}
-
-	//no value in the array
-	return -1;
-}
-
-struct Group_N group_N_self_range(double* time, int* censored, int size)
-{
-	int i, count_at, uncensored_num_at, censored_num_at;
-	double tmp, time_at;
-
-	// sort time and censored based on time together, time can censored array
-	struct point* time_censored_array = (struct point*) malloc(size * sizeof(struct point));
-
-	//censored, if censored[] is positive
-	for (i = 0; i < size; i++)
-	{
-		time_censored_array[i].x = time[i];
-		if (censored[i] > 0)
-			time_censored_array[i].y = 1;
-		else
-			time_censored_array[i].y = -1;
-	}
-
-	qsort(time_censored_array, size, sizeof(struct point), &point_compare_x);
-
-	//count unique uncensored time point
-	int count = 0;
-	for (i = 0; i < size; i++)
-	{	//uncensored
-		if (time_censored_array[i].y < 0)
-		{
-			if (count == 0)
-			{
-				count++;
-				tmp = time_censored_array[i].x;
-			}
-
-			if (count > 0)
-			{	//unique
-				if (time_censored_array[i].x != tmp)
-				{
-					count++;
-					tmp = time_censored_array[i].x;
-				}
-			}
-		}
-	}
-
-	double* unique_uncensored_time = (double *) malloc(count * sizeof(double));
-
-	count = 0;
-
-	for (i = 0; i < size; i++)
-	{
-		if (time_censored_array[i].y < 0)
-		{
-			if (count == 0)
-			{
-				count++;
-				unique_uncensored_time[count] = time_censored_array[i].x;
-				tmp = time_censored_array[i].x;
-
-			}
-
-			if (count > 0)
-			{
-				if (time_censored_array[i].x != tmp)
-				{
-					unique_uncensored_time[count] = time_censored_array[i].x;
-
-					count++;
-					tmp = time_censored_array[i].x;
-				}
-			}
-		}
-	}
-
-	int* uncensored_num = (int *) malloc(count * sizeof(int));
-	int* censored_num = (int *) malloc(count * sizeof(int));
-
-	//record current time point
-	time_at = unique_uncensored_time[0];
-	count_at = 0;
-	uncensored_num_at = 0;
-	censored_num_at = 0;
-
-	for (i = 0; i < size; i++)
-	{
-		if (time_censored_array[i].x <= time_at)
-		{
-			if (time_censored_array[i].y > 0)
-				censored_num_at++;
-			else
-				uncensored_num_at++;
-
-			if (i == size - 1)
-			{
-				uncensored_num[count_at] = uncensored_num_at;
-				censored_num[count_at] = censored_num_at;
-			}
-
-		} else {
-			uncensored_num[count_at] = uncensored_num_at;
-			censored_num[count_at] = censored_num_at;
-			count_at++;
-
-			uncensored_num_at = 0;
-			censored_num_at = 0;
-			time_at = unique_uncensored_time[count_at];
-			
-			if (time_censored_array[i].y > 0)
-				censored_num_at++;
-			else
-				uncensored_num_at++;
-		}
-	}
-
-	Group_N at_risk_result;
-	at_risk_result.uncensored = uncensored_num;
-	at_risk_result.censored = censored_num;
-	at_risk_result.size = count;
-	at_risk_result.time = unique_uncensored_time;
-	free(time_censored_array);
-	return at_risk_result;
-}
-
-struct Group_N group_N_given_range(double* time, int* censored, int size, double* unique_time, int unique_time_size)
-{
-	int i, count_at, uncensored_num_at, censored_num_at;
-	double time_at;
-
-	struct point* time_censored_array = (struct point*) malloc(size * sizeof(struct point));
-
-	for (i = 0; i < size; i++)
-	{
-		time_censored_array[i].x = time[i];
-		//not very fast here, prefer to define another point
-		if (censored[i] > 0)
-			time_censored_array[i].y = 1;
-		else
-			time_censored_array[i].y = -1;
-	}
-
-	qsort(time_censored_array, size, sizeof(struct point), &point_compare_x);
-
-	int* uncensored_num = (int *) malloc(unique_time_size * sizeof(int));
-	int* censored_num = (int *) malloc(unique_time_size * sizeof(int));
-
-	for (i = 0; i < unique_time_size; i++)
-	{
-		uncensored_num[i] = 0;
-		censored_num[i] = 0;
-	}
-
-	//record current time point
-	time_at = unique_time[0];
-	count_at = 0;
-	uncensored_num_at = 0;
-	censored_num_at = 0;
-
-	for (i = 0; i < size; i++)
-	{
-		if (time_censored_array[i].x <= time_at)
-		{
-			if (time_censored_array[i].y > 0)
-				censored_num_at++;
-			else
-				uncensored_num_at++;
-
-			if (i == size - 1)
-			{
-				uncensored_num[count_at] = uncensored_num_at;
-				censored_num[count_at] = censored_num_at;
-			}
-
-		} else {
-
-			while (time_censored_array[i].x > time_at)
-			{
-				uncensored_num[count_at] = uncensored_num_at;
-				censored_num[count_at] = censored_num_at;
-				count_at++;
-
-				uncensored_num_at = 0;
-				censored_num_at = 0;
-				time_at = unique_time[count_at];
-			}
-
-			if (time_censored_array[i].y > 0)
-				censored_num_at++;
-			else
-				uncensored_num_at++;
-		}
-	}
-
-	Group_N at_risk_result;
-	at_risk_result.uncensored = uncensored_num;
-	at_risk_result.censored = censored_num;
-	at_risk_result.size = unique_time_size;
-	at_risk_result.time = unique_time;
-
-	free(time_censored_array);
-
-	return at_risk_result;
-}
-
-#endif