/**
* Calculates the p-value of null Hypothesis
*
* @param flatDataCollection
* @param median
* @return
* @throws IllegalArgumentException
*/
public static double getPvalue(FlatDataCollection flatDataCollection, double median)
throws IllegalArgumentException {
int n = 0;
AssociativeArray Di = new AssociativeArray();
Iterator<Double> it = flatDataCollection.iteratorDouble();
while (it.hasNext()) {
double delta = it.next() - median;
if (delta == 0.0) {
continue; // don't count it at all
}
String key = "+";
if (delta < 0) {
key = "-";
}
Di.put(key + String.valueOf(n), Math.abs(delta));
++n;
}
if (n <= 0) {
throw new IllegalArgumentException();
}
// converts the values of the table with its Ranks
Di.toFlatDataList();
Ranks.getRanksFromValues(Di);
double W = 0.0;
for (Map.Entry<Object, Object> entry : Di.entrySet()) {
String key = entry.getKey().toString();
Double rank = TypeInference.toDouble(entry.getValue());
if (key.charAt(0) == '+') {
W += rank;
}
}
double pvalue = scoreToPvalue(W, n);
return pvalue;
}
/**
* 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;
}