Java - Array List

Hola Tengo el siguiente problema.
Tengo la función siguiente

static double dist_marginalx(int i, ArrayList PXY)
{
double pxy=0;
int tam = PXY.size();
for(int j=0; j < tam; j++){
ArrayList<double> aux = (ArrayList)(PXY.get(i));
pxy= pxy + ((double)(aux.get(j))).doubleValue();
}
return pxy;
}

Se supone que recibe entre otras cosas como parametro un ArrayList de ArrayList donde cada elemento del ultimo array list es un double.
Cuando quiero recuperar ese double me da problemas, me da errores de tipo.
¿Como puedo resolverlo?
Muchas gracias

Ya que un ArrayList almacena objetos y no valores primitivos creo que deberias cambiar:

pxy= pxy + ((double)(aux.get(j))).doubleValue();

por

pxy= pxy + ((Double)(aux.get(j))).doubleValue();

Saludos.

También ArrayList<double> por ArrayList<Double>, además de sacar eso fuera del for y de no hacerse lío con los índices y tamaños de los ArrayLists y de intentar no mezclar genéricos con colecciones no tipadas:

// Versión 1:
static double dist_marginalx(int i, ArrayList PXY) {
····double pxy=0;

····// Esto puede dar problemas. (Ver segunda versión)
····// Lo sacamos antes de entrar en el bucle, ya que sólo lo tenemos que sacar 1 vez
····ArrayList<Double> aux = (ArrayList)(PXY.get(i));
····int tamAux = aux.size(); // Este es el tamaño de aux

····for(int j=0; j < tamAux; j++){ // Lo que recorremos es aux, así que el límite es tamAux
········pxy += ((Double)(aux.get(j))).doubleValue();
····}
····return pxy;
}

Esa primera versión tiene aún varios problemas. Los más importantes son 2. Uno es técnico y el otro es un problema de organización:
- Mezcla ArrayList<Double> con ArrayList. Esto para empezar te dará un "unchecked warning" para indicarte que es algo poco fiable y que el compilador no puede garantizar que sea correcto. Además, puede llevar a errores en tiempo de compilación.
- El método dist_marginalx está recibiendo como parámetros mucha más información de la que realmente necesita. Le pasas el ArrayList PXY *entero* cuando a ese método sólo le interesa un elemento... que ya sabes cuál es a la hora de llamar porque se lo pasas también.

Por estas dos cosas sería más conveniente tener:

// Versión 2:
static double dist_marginalx(ArrayList<Double> lista) {
····double pxy=0;
····for(int i=0; i < lista.size(); i++){
········pxy += lista.get(i).doubleValue();
····}
····return pxy;
}

Esta segunda versión, además, no te obliga a tener todos los ArrayList<Double> dentro de otro ArrayList, lo cual es más conveniente por si en el futuro a lo mejor necesitas hacer el cálculo para un sólo ArrayList<Double> que no tiene por qué estar metido en otro ArrayList.
Que ese es otro asunto... ¿realmente encesitas tener los ArrayList<Double> dentro de un ArrayList en tu aplicación? Me hace pensar que quizá necesites dedicarle algo de tiempo a organizar mejor los datos o a diseñar mejor los objetos que manejas.

¿ de dónde has copiado (tan mal) este código ? Vaya lío que te estás armando.
Cómo no está claro qué quieres hacer, el error de tipo se solucionaría:

double pxy = 0.0;
...

pxy += aux.get(j); // Ya que cada elemento de aux es 'double'.

Por cierto: tam sería el número de ArrayList en PXY, no el número de doubles en aux ...