sstat 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b96bf3b381937bcd2c3c16a8b541afa2c39d989
-  data.tar.gz: 6248e20409fd066b6080a0b39fa313dcb29c5f4d
+  metadata.gz: beee6865b0bc618d70c67be9c3f000089416b24e
+  data.tar.gz: 21761e26f6a5af3402d3adc1d12e4a2af33897ce
 SHA512:
-  metadata.gz: 9946b07ecb155b9f73c0f588f72e99903ad0128d3379db090dfc2351300ec0e6fa435d777d8001f43575a0085cc56785191d3ace9ab5e55de33f4fbda07b6029
-  data.tar.gz: 7746a88b653e1277ca530ddc2b0126385d9146609af081e9f4e238db2fabc01108212c6534394391890bc3663005a4cbc4ab663355c38a6947cfbf78983227bf
+  metadata.gz: d994e68d96cdebf07f8a2da62c14329eb0c65f29cedcc3c5f71563f6af7de1b1f480e608fa1a575d7129122dbf7da5d5a42976aac4ff9f27ef111c741dbcb0f2
+  data.tar.gz: bbe5ab1b30dbaeee27995d678b2dcf64e8d5a0b456e263d12d8685464a95da119d4145deb431444a49c278b6846ad375e87e9c877ebdb63cb3a7d0b90d11bce3

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "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/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/sstat/Makefile

@@ -0,0 +1,238 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose.  other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+ECHO1 = $(V:1=@:)
+ECHO = $(ECHO1:0=@echo)
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /home/chizhang/.rvm/rubies/ruby-2.1.1/include/ruby-2.1.0
+hdrdir = $(topdir)
+arch_hdrdir = /home/chizhang/.rvm/rubies/ruby-2.1.1/include/ruby-2.1.0/x86_64-linux
+PATH_SEPARATOR = :
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = $(DESTDIR)/home/chizhang/.rvm/rubies/ruby-2.1.1
+rubysitearchprefix = $(rubylibprefix)/$(sitearch)
+rubyarchprefix = $(rubylibprefix)/$(arch)
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
+sitearchhdrdir = $(sitehdrdir)/$(sitearch)
+rubyarchhdrdir = $(rubyhdrdir)/$(arch)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitearchdir = $(sitelibdir)/$(sitearch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitedir = $(rubylibprefix)/site_ruby
+rubyarchdir = $(rubylibdir)/$(arch)
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+sitearchincludedir = $(includedir)/$(sitearch)
+archincludedir = $(includedir)/$(arch)
+sitearchlibdir = $(libdir)/$(sitearch)
+archlibdir = $(libdir)/$(arch)
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(DESTDIR)/usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+archdir = $(rubyarchdir)
+
+
+CC = gcc
+CXX = g++
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -Wl,-R -Wl,$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -Wl,-R -Wl,$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)-static
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+
+RUBY_EXTCONF_H = 
+cflags   =  $(optflags) $(debugflags) $(warnflags)
+optflags = -O3 -fno-fast-math
+debugflags = -ggdb3
+warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wunused-variable -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wimplicit-function-declaration
+CCDLFLAGS = -fPIC
+CFLAGS   = $(CCDLFLAGS) $(cflags)  -fPIC -std=gnu99 -Wno-declaration-after-statement $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =   $(DEFS) $(cppflags)
+CXXFLAGS = $(CCDLFLAGS) $(cxxflags) $(ARCH_FLAG)
+ldflags  = -L. -fstack-protector -rdynamic -Wl,-export-dynamic
+dldflags =  
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -shared
+LDSHAREDXX = $(CXX) -shared
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby
+RUBYW_INSTALL_NAME = 
+RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
+RUBYW_BASE_NAME = rubyw
+RUBY_BASE_NAME = ruby
+
+arch = x86_64-linux
+sitearch = $(arch)
+ruby_version = 2.1.0
+ruby = $(bindir)/ruby
+RUBY = $(ruby)
+ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h
+
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir --ignore-fail-on-non-empty -p
+MAKEDIRS = /bin/mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir) -Wl,-R$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl -lcrypt -lm   -lc
+ORIG_SRCS = sstat.c
+SRCS = $(ORIG_SRCS) 
+OBJS = sstat.o
+HDRS = $(srcdir)/sstat.h
+TARGET = sstat
+TARGET_NAME = sstat
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+TIMESTAMP_DIR = .
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-static clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+		-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean-static::
+distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
+		-$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		-$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		-$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(DLLIB) $(TIMESTAMP_DIR)/.RUBYARCHDIR.time
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+clean-static::
+	-$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+pre-install-rb-default:
+	$(ECHO) installing default sstat libraries
+$(TIMESTAMP_DIR)/.RUBYARCHDIR.time:
+	$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+	$(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .C .o
+
+.cc.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.mm.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cxx.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cpp.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.C.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.c.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+.m.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	$(ECHO) linking shared-object $(DLLIB)
+	-$(Q)$(RM) $(@)
+	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): $(HDRS) $(ruby_headers)

data/ext/sstat/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/sstat/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/sstat/lib/survival.h

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

data/ext/sstat/lib/survival_def.h

@@ -0,0 +1,15 @@
+#ifndef _SURVIVAL_STAT_DEF_H_
+#define _SURVIVAL_STAT_DEF_H_
+
+#include "type_def.h"
+//define survival stat data
+
+typedef struct Group_N
+{
+	int * uncensored;
+	int * censored;
+	double* time;
+	int size;
+} Group_N;
+
+#endif

data/ext/sstat/lib/survival_func.h

@@ -0,0 +1,190 @@
+#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;
+}
+
+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/sstat/lib/survival_utility.h

@@ -0,0 +1,292 @@
+#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;
+	//To speed up, choose to do not memset arr.
+	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];
+			//we need to update here
+			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

data/ext/sstat/lib/type_def.h

@@ -0,0 +1,35 @@
+#ifndef _SSTAT_TYPE_DEF_H_
+#define _SSTAT_TYPE_DEF_H_
+
+//EPSILON here is set based on ruby float. we need to chagne it for other project
+#define EPSILON 2.2204460492503131e-16
+
+//The following constants are from ATMEL http://www.atmel.com/webdoc/
+#define M_2_SQRTPI 1.12837916709551257390
+#define M_SQRT1_2 0.70710678118654752440
+#define M_1_SQRT2PI (M_2_SQRTPI * M_SQRT1_2 / 2.0)
+#define M_SQRT2 1.41421356237309504880
+#define SQRT32 (4.0 * M_SQRT2)
+
+//GSL constants for gaussian distribution
+#define GAUSS_XUPPER (8.572)
+#define GAUSS_XLOWER (-37)
+#define GAUSS_SCALE (16.0)
+#define GAUSS_EPSILON 1e-12
+
+typedef struct point{
+	double x;
+	double y;
+} point;
+
+typedef struct curve{
+	struct point* point_array;
+	int size;
+} curve;
+
+typedef struct array{
+	double* D_ptr;
+	int size;
+} array;
+
+#endif

data/ext/sstat/sstat.c

@@ -0,0 +1,107 @@
+#include "sstat.h"
+
+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);
+}
+
+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));
+  }
+
+  _index = index_less_equal(c_array, size, _target);
+
+  free(c_array);
+
+  return INT2NUM(_index);
+}
+
+static VALUE rb_kaplan_meier(VALUE self, VALUE time, VALUE censored)
+{
+  int size = RARRAY_LEN(time);
+  int i;
+  struct curve KM_curve;
+  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));
+  }
+  KM_curve = kaplan_meier(_time, _censored, size);
+
+  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;
+}
+
+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));
+  }
+  _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);
+}
+
+static VALUE rb_cdf_unormal_Q(VALUE self, VALUE x)
+{
+  double Q = cdf_ugaussian_Q(NUM2DBL(x));
+  return DBL2NUM(Q);
+}

data/ext/sstat/sstat.h

@@ -0,0 +1,28 @@
+#ifndef _SSTAT_H_
+#define _SSTAT_H_
+#include <ruby.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "lib/survival.h"
+#include "lib/global_utility.h"
+#include "lib/distribution.h"
+
+static VALUE rb_percentile(VALUE self, VALUE arg, VALUE target);
+static VALUE rb_index_less_equal(VALUE self, VALUE arg, VALUE target);
+static VALUE rb_kaplan_meier(VALUE self, VALUE time, VALUE censor);
+static VALUE rb_log_rank_test(VALUE self, VALUE time_1, VALUE censor_1,VALUE time_2, VALUE censor_2);
+static VALUE rb_cdf_unormal_Q(VALUE self, VALUE x);
+
+//rb_ary_storde(unmasked, i, INT2NUM(p ^ m));
+void Init_sstat() {
+	VALUE sstat_module = rb_define_module("SStat");
+	VALUE basic_class = rb_define_class_under(sstat_module, "Basic", rb_cObject);
+
+	rb_define_method(basic_class, "percentile", rb_percentile, 2);
+	rb_define_method(basic_class, "index_less_equal", rb_index_less_equal, 2);
+	rb_define_method(basic_class, "kaplan_meier", rb_kaplan_meier, 2);
+	rb_define_method(basic_class, "log_rank_test", rb_log_rank_test, 4);
+	rb_define_method(basic_class, "cdf_unormal_Q", rb_cdf_unormal_Q, 1);
+}
+
+#endif

data/lib/simple_statistics.rb

@@ -0,0 +1,5 @@
+require "simple_statistics/version"
+
+module SimpleStatistics
+  # Your code goes here...
+end

data/lib/simple_statistics/version.rb

@@ -0,0 +1,3 @@
+module SimpleStatistics
+  VERSION = "0.1.0"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sstat
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Haipeng Li
@@ -19,7 +19,22 @@ extensions:
 - ext/sstat/extconf.rb
 extra_rdoc_files: []
 files:
+- bin/console
+- bin/setup
+- ext/sstat/Makefile
 - ext/sstat/extconf.rb
+- ext/sstat/lib/distribution.h
+- ext/sstat/lib/global_utility.h
+- ext/sstat/lib/survival.h
+- ext/sstat/lib/survival_def.h
+- ext/sstat/lib/survival_func.h
+- ext/sstat/lib/survival_utility.h
+- ext/sstat/lib/type_def.h
+- ext/sstat/sstat.c
+- ext/sstat/sstat.h
+- lib/simple_statistics.rb
+- lib/simple_statistics/version.rb
+- lib/sstat.so
 homepage: 
 licenses: []
 metadata: {}