/** Test of test method, of class Logrank. */
@Test
public void testTest() {
System.out.println("test");
// Example from Dimaki's Survival Non-parametrics notes. It should reject the null hypothesis
// and return true.
TransposeDataCollection transposeDataCollection = new TransposeDataCollection();
transposeDataCollection.put(
0, new FlatDataCollection(Arrays.asList(new Object[] {23, "16+", "18+", "20+", "24+"})));
transposeDataCollection.put(
1, new FlatDataCollection(Arrays.asList(new Object[] {15, 18, 19, 19, 20.0})));
boolean is_twoTailed = true;
double aLevel = 0.05;
boolean expResult = true;
boolean result = Logrank.test(transposeDataCollection, is_twoTailed, aLevel);
assertEquals(expResult, result);
}
/** Test of testVariances method, of class LevenesIndependentSamples. */
@Test
public void testTestVariances() {
logger.info("testVariances");
TransposeDataCollection transposeDataCollection = new TransposeDataCollection();
transposeDataCollection.put(
0, new FlatDataCollection(Arrays.asList(new Object[] {60.8, 57.0, 65.0, 58.6, 61.7})));
transposeDataCollection.put(
1, new FlatDataCollection(Arrays.asList(new Object[] {68.7, 67.7, 74.0, 66.3, 69.8})));
transposeDataCollection.put(
2, new FlatDataCollection(Arrays.asList(new Object[] {102.6, 103.1, 100.2, 96.5})));
transposeDataCollection.put(
3, new FlatDataCollection(Arrays.asList(new Object[] {87.9, 84.2, 83.1, 85.7, 90.3})));
double aLevel = 0.05;
boolean expResult = true;
boolean result = LevenesIndependentSamples.testVariances(transposeDataCollection, aLevel);
assertEquals(expResult, result);
}
/**
* Calculates the p-value of null Hypothesis.
*
* @param transposeDataCollection
* @return
* @throws IllegalArgumentException
*/
public static double getPvalue(TransposeDataCollection transposeDataCollection)
throws IllegalArgumentException {
if (transposeDataCollection.size() != 2) {
throw new IllegalArgumentException();
}
Object[] keys = transposeDataCollection.keySet().toArray();
// counter of uncencored internalData in each group
Map<Object, Integer> n = new HashMap<>();
n.put(keys[0], 0);
n.put(keys[1], 0);
Queue<Double> censoredData = new PriorityQueue<>();
Queue<Double> uncensoredData = new PriorityQueue<>();
for (Map.Entry<Object, FlatDataCollection> entry : transposeDataCollection.entrySet()) {
Object j = entry.getKey();
FlatDataCollection flatDataCollection = entry.getValue();
for (Object value : flatDataCollection) {
String str = value.toString();
if (str.endsWith(CensoredDescriptives.CENSORED_NUMBER_POSTFIX)) {
// censored internalData encoded as 4.3+ or -4.3+
censoredData.add(
Double.valueOf(
str.substring(
0,
str.length()
- CensoredDescriptives.CENSORED_NUMBER_POSTFIX
.length()))); // remove the trailing char and convert it to double
} else {
// uncensored internalData
uncensoredData.add(TypeInference.toDouble(value)); // convert it to double
}
n.put(j, n.get(j) + 1);
}
}
Double currentCensored = null;
Double currentUncensored = null;
AssociativeArray2D testTable = new AssociativeArray2D();
do {
if (currentCensored == null) {
currentCensored = censoredData.poll();
}
if (currentUncensored == null) {
currentUncensored = uncensoredData.poll();
}
Double ti;
String key;
if (currentUncensored == null) {
key = currentCensored.toString().concat((CensoredDescriptives.CENSORED_NUMBER_POSTFIX));
ti = currentCensored;
currentCensored = null;
} else if (currentCensored == null) {
key = currentUncensored.toString();
ti = currentUncensored;
currentUncensored = null;
} else if (currentCensored
< currentUncensored) { // NOT EQUAL! Uncensored internalData of the same value are always
// larger
key = currentCensored.toString().concat(CensoredDescriptives.CENSORED_NUMBER_POSTFIX);
ti = currentCensored;
currentCensored = null;
} else {
key = currentUncensored.toString();
ti = currentUncensored;
currentUncensored = null;
}
Object value = testTable.get2d(key, "mi");
if (value == null) {
testTable.put2d(key, "mi", 1);
testTable.put2d(key, "rti", 0);
} else {
testTable.put2d(key, "mi", ((Integer) value) + 1);
continue; // continue in order not to count twice the r*ti below
}
for (Map.Entry<Object, FlatDataCollection> entry : transposeDataCollection.entrySet()) {
Object j = entry.getKey();
FlatDataCollection flatDataCollection = entry.getValue();
for (Object value2 : flatDataCollection) {
double v;
String str = value2.toString();
if (str.endsWith(CensoredDescriptives.CENSORED_NUMBER_POSTFIX)) {
// censored internalData encoded as 4.3+ or -4.3+
v =
Double.valueOf(
str.substring(
0,
str.length()
- CensoredDescriptives.CENSORED_NUMBER_POSTFIX
.length())); // remove the trailing char and convert it to double
} else {
// uncensored internalData
v = TypeInference.toDouble(value2); // convert it to double
}
if (v >= ti) {
testTable.put2d(key, "rti", (Integer) testTable.get2d(key, "rti") + 1);
}
}
}
} while (currentCensored != null
|| currentUncensored != null
|| !censoredData.isEmpty()
|| !uncensoredData.isEmpty());
censoredData = null;
uncensoredData = null;
double VarS = 0.0;
Object previousUncencoredKey = null;
for (Map.Entry<Object, AssociativeArray> entry : testTable.entrySet()) {
Object ti = entry.getKey();
AssociativeArray testRow = entry.getValue();
double previousUncencoredValue = 0;
Object tmp = testTable.get2d(previousUncencoredKey, "eti");
if (tmp != null) {
previousUncencoredValue = TypeInference.toDouble(tmp);
}
if (!ti.toString().endsWith(CensoredDescriptives.CENSORED_NUMBER_POSTFIX)) { // uncensored
double mi = testRow.getDouble("mi");
double rti = testRow.getDouble("rti");
double eti = previousUncencoredValue + mi / rti;
testRow.put("eti", eti);
testRow.put("wi", 1 - eti);
previousUncencoredKey = ti;
} else { // censored
testRow.put("wi", -previousUncencoredValue);
}
double wi = testRow.getDouble("wi");
VarS += testRow.getDouble("mi") * wi * wi;
}
double S = 0.0;
for (Object value : transposeDataCollection.get(keys[0])) { // if ti belongs to the first group
Object
key; // we must first convert the number into to double and then append the + if
// necessary. This is why it's converted like this.
String str = value.toString();
if (str.endsWith(CensoredDescriptives.CENSORED_NUMBER_POSTFIX)) {
// censored internalData encoded as 4.3+ or -4.3+
Double v =
Double.valueOf(
str.substring(
0,
str.length()
- CensoredDescriptives.CENSORED_NUMBER_POSTFIX
.length())); // remove the trailing char and convert it to double
key = v.toString() + CensoredDescriptives.CENSORED_NUMBER_POSTFIX;
} else {
// uncensored internalData
Double v = TypeInference.toDouble(value); // convert it to double
key = v.toString();
}
double wi = TypeInference.toDouble(testTable.get2d(key, "wi"));
S += wi;
}
testTable = null;
double n0 = n.get(keys[0]).doubleValue();
double n1 = n.get(keys[1]).doubleValue();
VarS *= n0 * n1 / ((n0 + n1) * (n0 + n1 - 1.0));
double Z = S / Math.sqrt(VarS);
double pvalue = scoreToPvalue(Z);
return pvalue;
}