Dificuldade em popular float[][] - combinação dois a dois

Programação Java
#1

Pessoal,

Tenho uma situação onde preciso popular um float[][] a partir de um float[]. Quero garantir que os valores em float[][] sejam únicos. Pensei na estratégia abaixo:

[code]public float[][] buildTwoDimensionFloatArray(float[] oneDimensionFloatArray) {

	int c = SimpleCombination2by2(oneDimensionFloatArray);  // retorna o fatorial para oneDimensionFloatArray
	
	twoDimensionFloatArray = new float[c][2]; // cria o float[][] com dimensões (c,2)
	
	float[] oneDimensionFloatArrayMinus1 = new float[oneDimensionFloatArray.length - 1]; // cria um float[] com tamanho igual a (oneDimensionFloatArray - 1)

	for (int i = 0 ; i < oneDimensionFloatArray.length ; i++) {
		
		float removedFloat = oneDimensionFloatArray[i];  // armazena o valor removido de oneDimensionFloatArray
		
                    for (int j = 1 ; j < oneDimensionFloatArray.length ; j++) {
                    oneDimensionFloatArrayMinus1[j -1] = oneDimensionFloatArray[j];  // popula o oneDimensionFloatArrayMinus1 a partir de oneDimensionFloatArray
                    }

		for (int k = 1 ; k < oneDimensionFloatArrayMinus1.length ; k++) {
			float nextFloat = oneDimensionFloatArrayMinus1[k];
			fuzzyPairs[removedFloat][nextFloat];
		}
	}
	
	return fuzzyPairs;
	
}

    private int SimpleCombination2by2(float[] oneDimensionFloatArray) {
	BigInteger C = BigInteger.ZERO;

	int c = 0;
	
	int m = oneDimensionFloatArray.length;
	int p = 2;
	
	BigInteger M = getFactorial(m);
	BigInteger mMinusP = getFactorial(m - p);
	BigInteger P = getFactorial(p);
	
	C = M.divide((mMinusP.multiply(P))); 

	c = C.intValue();
	
	return c; // retorna a quantidade de possíveis combinações simples (sem repetição) de oneDimensionFloatArray.
}[/code]

A linha abaixo retorna um erro dizendo que não pode converter de float para int

fuzzyPairs[removedFloat][nextFloat];

Mas, quando eu defino o float[][] como abaixo, eu não estou apenas informando as dimensões?

float[][] twoDimensionFloatArray = new float[c][2];

Obrigado desde já!
Gustavo

#2

Ola, o seu problema acontece prq a linguagem java não permite que vc “indexe” um array com 64bits, em outras palavras, vc pode apenas criar (ou utilizar como no seu caso) o indice do seu array com int e não com long.

array[aqui não pode vir um long como vc esta fazer, pode apenas vir um int];

Se a linha abaixo compilase vc não estaria fazendo nada, apenas pegando o valor que esta no indice e não atribuindo ele a lugar nenhum

fuzzyPairs[removedFloat][nextFloat];
#3

Troque

fuzzyPairs[removedFloat][nextFloat]

por

fuzzyPairs[(int)removedFloat][(int)nextFloat]

(embora eu esteja achando que não é exatamente isso que você quer, mas…)

#4

Pessoal,

Obrigado pelas dicas, mas o problema é que eu realmente preciso de float[][].

Acho que vou ter que usar um HashMap…

Thanks =)

#5

oi,

se vc precisa que os valores sejam únicos use um Set, um HashSet deve servir

[]´s

#6

Há aí algo esquisito no teu código.

Crias o array twoDimensionFloatArray mas não o usas.

E depois “usas” o array fuzzyPairs, que também retornas mas que nunca foi inicializado. Pus usas entre aspas porque simplesmente aquela declaração não faz sentido, não estas a atribuir valor nenhum ao array, nem a usar nenhum valor do array.

De certeza que para além do “Type mismatch: cannot convert from float to int” também deve estar a dar “Syntax error, insert “AssignmentOperator Expression” to complete Expression”

#7