I’ll try to help you, but you also have to work on your own.
This code does NOT yet use JCuda for anything. It is just reading the input data, namely the first Sheet of the Table, which has to be present as a CSV file. It is implemented as a quick hack. Not as much a hack as the XLS reader, but still ugly.
Are the values correct? How should the Fisher test be applied to the ‘count’ tables?
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class JCudaFisherTestMain
{
private static final Map<String, Integer> valueToIndex = new LinkedHashMap<String, Integer>();
static
{
valueToIndex.put("A/A", 0);
valueToIndex.put("A/C", 1);
valueToIndex.put("A/G", 2);
valueToIndex.put("A/T", 3);
valueToIndex.put("C/A", 4);
valueToIndex.put("C/C", 5);
valueToIndex.put("C/G", 6);
valueToIndex.put("C/T", 7);
valueToIndex.put("G/A", 8);
valueToIndex.put("G/C", 9);
valueToIndex.put("G/G", 10);
valueToIndex.put("G/T", 11);
valueToIndex.put("T/A", 12);
valueToIndex.put("T/C", 13);
valueToIndex.put("T/G", 14);
valueToIndex.put("T/T", 15);
valueToIndex.put("NoCall", 16);
valueToIndex.put("-/-", 17);
valueToIndex.put("-/A", 18);
valueToIndex.put("-/C", 19);
valueToIndex.put("-/G", 20);
valueToIndex.put("-/T", 21);
valueToIndex.put("A/-", 22);
valueToIndex.put("C/-", 23);
valueToIndex.put("G/-", 24);
valueToIndex.put("T/-", 25);
}
public static void main(String[] args) throws Exception
{
SimpleTableData table = SimpleTableData.read("FirstTable.csv");
List<Integer> sickColumns = Arrays.asList(
2, 3, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 25, 27
);
Set<Integer> set = new LinkedHashSet<Integer>();
for (int i=1; i<table.getNumCols(); i++)
{
set.add(i);
}
set.removeAll(sickColumns);
List<Integer> healthyColumns = new ArrayList<Integer>(set);
SimpleTableData sickTable = SimpleTableData.create(table, sickColumns);
SimpleTableData healthyTable = SimpleTableData.create(table, healthyColumns);
System.out.println("Start of sick table");
System.out.println(sickTable.toString(5));
System.out.println("Start of healthy table");
System.out.println(healthyTable.toString(5));
int sickCount[] = createCountMatrix(sickTable);
int healthyCount[] = createCountMatrix(healthyTable);
System.out.println("Sick count");
System.out.println(toString2D(sickCount, valueToIndex.size()));
System.out.println("Healthy count");
System.out.println(toString2D(healthyCount, valueToIndex.size()));
}
private static int[] createCountMatrix(TableData tableData)
{
int result[] = new int[valueToIndex.size() * tableData.getNumRows()];
for (int r=0; r<tableData.getNumRows(); r++)
{
for (int c=0; c<tableData.getNumCols(); c++)
{
String value = tableData.get(r, c);
Integer index = valueToIndex.get(value);
if (index != null)
{
int arrayIndex = r * valueToIndex.size() + index;
result[arrayIndex]++;
}
}
}
return result;
}
public static String toString2D(int a[], int columns)
{
StringBuilder sb = new StringBuilder();
for (int i=0; i<a.length; i++)
{
if (i>0 && i % columns == 0)
{
sb.append("
");
}
sb.append(String.format("%4s ", String.valueOf(a**)));
}
return sb.toString();
}
}
interface TableData
{
String get(int row, int col);
int getNumRows();
int getNumCols();
}
class SimpleTableData implements TableData
{
private List<String> headers = null;
private List<List<String>> data = null;
public static SimpleTableData create(SimpleTableData other, List<Integer> columns)
{
SimpleTableData result = new SimpleTableData();
result.headers = new ArrayList<String>();
for (Integer column : columns)
{
result.headers.add(other.getHeader(column));
}
result.data = new ArrayList<List<String>>();
for (int r=0; r<other.getNumRows(); r++)
{
List<String> row = new ArrayList<String>();
for (Integer column : columns)
{
row.add(other.get(r, column));
}
result.data.add(row);
}
return result;
}
public static SimpleTableData read(String csvFileName) throws IOException
{
SimpleTableData result = new SimpleTableData();
result.data = new ArrayList<List<String>>();
BufferedReader r = new BufferedReader(
new InputStreamReader(new FileInputStream(csvFileName)));
String line = null;
while (true)
{
line = r.readLine();
if (line == null)
{
break;
}
String tokens[] = line.split(",");
if (result.headers == null)
{
result.headers = Arrays.asList(tokens);
}
else
{
result.data.add(Arrays.asList(tokens));
}
}
return result;
}
@Override
public int getNumRows()
{
return data.size();
}
@Override
public int getNumCols()
{
return headers.size();
}
@Override
public String get(int row, int col)
{
return data.get(row).get(col);
}
public List<String> getHeaders()
{
return headers;
}
public String getHeader(int col)
{
return headers.get(col);
}
public List<String> getRow(int row)
{
return data.get(row);
}
public List<String> getColumn(String name)
{
for (int i=0; i<getNumCols(); i++)
{
if (getHeader(i).equals(name))
{
return getColumn(i);
}
}
return null;
}
public List<String> getColumn(final int col)
{
return new AbstractList<String>()
{
@Override
public String get(int index)
{
return SimpleTableData.this.get(col, index);
}
@Override
public int size()
{
return getNumRows();
}};
}
public String toString(int numRows)
{
StringBuilder sb = new StringBuilder();
sb.append(headers);
sb.append("
");
for (int i=0; i<numRows; i++)
{
sb.append(getRow(i));
sb.append("
");
}
sb.append("...
");
return sb.toString();
}
}
great.