Somatório de elementos de uma dimensão / Matriz

[carol_ana]

Minha dúvida é a seguinte, preciso realizar a soma dos elementos de apenas uma dimensão de uma matriz. Para teste fiz algo simples veja o código abaixo:

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class soma_teste {

public static void main(String[] args) {
	InputStreamReader read = new InputStreamReader(System.in);
	BufferedReader br = new BufferedReader(read);
	
	int[][] arr = new int[3][2];
	loadData(arr);
	
	int sum = 0;
	for (int i = 2; i < 3; i++) {
		
	for (int j = 0; j < 2; j++) {
		System.out.print(arr[i][j] + " ");
	sum += arr[i][j];
	
	
	}
	}
	System.out.println(sum);
	


}
}

Nesse código fiz para realizar a soma dos elementos da dimensão [3], só que acredito que não esteja fazendo de maneira correta, pois quando peço para imprimir os valores dos elementos dessa dimensão esta vindo algo do tipo, só valores pares, não sei se fiz certo isso.

[esdmorais]

Bom dia!

Se você quer fazer somente da dimensão três, não precisa fazer dois laços de repetição.
Você poderia fazer da seguinte maneira:

for (int j = 0; j < 2; j++) {  
    sum += arr[2][j];  
    System.out.print(arr[2][j] +" ");  
}
System.out.println(sum);

E mais uma coisa… não se esqueça de preencher o vetor com os valores antes… senão só aparecerá zero haushaushuash

[carol_ana]

Então…eu tb achei que iria vir só zero …mas esta exibindo valores, por isso não sei se esta certo.

Pq no print ele exibe isso:

1 2 3 4 5 6
soma 21

Isso quando faço a soma da matriz inteira…ele esta exibindo esses valores. Será que esta errado?

[esdmorais]

Então… eu percebi que tem um método ai que você não postou aqui, o

 loadData(arr); 

Provavelmente o seu vetor está sendo preenchido aí dentro, não?

[carol_ana]

Tinha esquecido desse metodo. Obrigada pelas respostas, pela ajuda.

[carol_ana]

Espera aí…acho que me perdi agora…nesse caso o for que vc fez acima, não esta fazendo a soma dos elementos da dimensão [2]? Não entendi.

[esdmorais]

Você disse que queria que calculasse a soma somente dos elementos da dimensão 3, né?
Foi isso o que eu fiz, coloquei para calcular a soma somente dos elementos da terceira dimensão, ou seja, dimensão com índice 2.
Entendeu?? hehe

[carol_ana]

Acho que entendi…

No caso leio a dimensão, veja o meu código: [code]
import java.io.DataInputStream;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class ReadFile {

/****************************************************
 * Metodo criado para receber as duas Matrizes 4D 
 ****************************************************/
public static double[][][][] criaMatriz4D(int dim1, int dim2, int dim3, int dim4, DataInputStream input) throws IOException{
    double[][][][] matriz = new double[dim1][dim2][dim3][dim4];
   
    for (int l = 0; l < dim4; l++) {
            for (int k = 0; k < dim3; k++) {
                    for (int j = 0; j < dim2; j++) {
                            for (int i = 0; i < dim1; i++) {
                                    matriz[i][j][k][l] = input.readDouble();
                                    
                            }
                    }
            }
    } 
    return matriz;

}

/****************************************************
* Metodo criado para receber as duas Matrizes 3D 
****************************************************/
public static float[][][] criaMatriz3D(int dim2, int dim3, int dim4, DataInputStream input) throws IOException{
    float[][][] matriz = new float[dim2][dim3][dim4];
   
    
            for (int k = 0; k < dim4; k++) {
                    for (int j = 0; j < dim3; j++) {
                            for (int i = 0; i < dim2; i++) {
                                    matriz[i][j][k] = input.readFloat();
                                    
                            }
                    }
            }
     
    return matriz;

}

public static void main(String args[]) throws IOException {

	// Realizando a leitura do arquivo binário
	DataInputStream input = new DataInputStream(new FileInputStream(new File("C:/Documents and Settings/Projeto_Estudo/data.dtb")));

	// Lendo as dimensões gravadas no binário
	int dim1 = 4; // dimensão fixa
	int dim2 = input.readInt(); // dimensão lida do arquivo binário
	int dim3 = input.readInt(); // dimensão lida do arquivo binário
	int dim4 = input.readInt(); // dimensão lida do arquivo binário
	
	// Exibo os valores de cada dimensão, só para verificar se esta "pegando" valor correto
	System.out.println("Dimensão1= " +dim1);
	System.out.println("Dimensão2= " +dim2);
	System.out.println("Dimensão3= " +dim3);
	System.out.println("Dimensão4= " +dim4);
	
	// Guardo os valores das respectivas matrizes	
	double [][][][] mat_modImag = criaMatriz4D(4, dim2, dim3, dim4, input);
	double [][][][] mat_conjImag = criaMatriz4D(4, dim2, dim3, dim4, input);
	float [][][] mat_modScatter = criaMatriz3D(dim2, dim3, dim4, input);
	float [][][] mat_conjScatter = criaMatriz3D(dim2, dim3, dim4, input);
	
	// Fechando a leitura
	input.close();
	
	
	// Imprime as posições das matrizes
	System.out.println(mat_modImag[0][0][16][16]); 
	System.out.println(mat_conjImag[0][0][19][16]);
	System.out.println(mat_modScatter[1][2][1]);
	System.out.println(mat_conjScatter[14][16][3]);
	
}




// Metodo para imprimir as matrizes
private static void imprimeMatriz(double[][][][] matriz) {
	System.out.println("----");
	for (int i = 0; i < matriz.length; i++) {
		for (int j = 0; j < matriz[i].length; j++) {
			for (int k = 0; k < matriz[i][j].length; k++) {
				System.out.print("  ");
				for (int l = 0; l < matriz[i][j][k].length; l++) {
					//System.out.print(matriz[i][j][k][l] + " ");
				}
				System.out.println();
			}
			System.out.println("--");
		}
		System.out.println("----");
	}
}

}[/code]

Então se quero somar os elementos da dimensão [dim4] da matriz criaMatriz4D. Daí então ficaria assim: Pois nesse caso leio a dimensão de um arquivo.

for (int l = 0; l < dim4; l++) { sum += arr[i][j][k][dim4]; System.out.print(arr[i][j][k][dim4] +" "); } System.out.println(sum);

[esdmorais]

Então, se a sua matriz tem quatro dimensões e quer somar os elementos da quarta, você tem que fazer algo mais ou menos assim:

for (int i = 0; i < dim4; i++) {
    sum += arr[dim1][dim2][dim3][i];
}

Você tem que dizer ao programa que é a dimensão quatro que está dentro de uma determinada dimensão três que está dentro de uma dimensão dois que está dentro de uma dimensão um que você definir…

[carol_ana]

Então no caso fiz meu metodo assim:

public static double soma(double[][][][] mat_modImag, int dim1, int dim2, int dim3, int dim4){
		    int somatorio = 0;
		    for(int l = 0; l < dim4; l++){ 	
		    		somatorio += mat_modImag[dim1][dim2][dim3][l];
		    		
		    }
		    
		    System.out.println("a soma eh =" +somatorio);
		    return somatorio;
		  }

Pelo que percebi ele não esta entrando no metodo, pedi para exibir um simples Print e não exibiu nada, executei o “Debug” no Eclipse e tb não exibe nada de erro.

[esdmorais]

Então Carol, verifique pelo Debug nesse método qual é o valor da variável dim4 porque se o valor for menor que zero, ele não vai passar pelo for mesmo!

[carol_ana]

Então coloquei um breakpoint dentro do metodo “soma” esta exibindo isso. Esse “0” que ele exibe pode ser alguma coisa?

ReadFile [Java Application]
ReadFile at localhost:2138
<terminated, exit value: 0>C:\Arquivos de programas\Java\jre6\bin\javaw.exe (09/12/2011 13:50:44)

[esdmorais]

Quer dizer que não somou =/
Veja qual é o valor da variável dim4
Estou achando que dim4 está sendo definida como zero, por isso que não tem como ela entrar dentro do laço.

[carol_ana]

No código que enviei acima na linha 68 peço para exibir a dimensão de dim4: System.out.println("Dimensão4= " +dim4); esta exibindo a dimensão correta que no caso é 32, só que não entra dentro do metodo soma.

[esdmorais]

Faz um favor, manda a sua classe completa até agora, com tudo e até o seu método soma por favor.

[carol_ana]

Meu código completo:

import java.io.DataInputStream;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;


public class ReadFile {
	
	/****************************************************
	 * Metodo criado para receber as duas Matrizes 4D 
	 ****************************************************/
	public static double[][][][] criaMatriz4D(int dim1, int dim2, int dim3, int dim4, DataInputStream input) throws IOException{
        double[][][][] matriz = new double[dim1][dim2][dim3][dim4];
       
        for (int l = 0; l < dim4; l++) {
                for (int k = 0; k < dim3; k++) {
                        for (int j = 0; j < dim2; j++) {
                                for (int i = 0; i < dim1; i++) {
                                        matriz[i][j][k][l] = input.readDouble();
                                        
                                }
                        }
                }
        } 
        return matriz;
}
	
	/****************************************************
	* Metodo criado para receber as duas Matrizes 3D 
	****************************************************/
	public static float[][][] criaMatriz3D(int dim2, int dim3, int dim4, DataInputStream input) throws IOException{
        float[][][] matriz = new float[dim2][dim3][dim4];
       
        
                for (int k = 0; k < dim4; k++) {
                        for (int j = 0; j < dim3; j++) {
                                for (int i = 0; i < dim2; i++) {
                                        matriz[i][j][k] = input.readFloat();
                                        
                                }
                        }
                }
         
        return matriz;
}
	
	
	/*********************************************
	 * Metodo para realizar somatorio das matrizes 
	 *********************************************/
	
	 public static double soma(double[][][][] mat_modImag, int dim1, int dim2, int dim3, int dim4){
		 System.out.println("dim4 =" +dim4);
		    int somatorio = 0;
		    for(int l = 0; l < dim4; l++){		    		
		    	somatorio += mat_modImag[dim1][dim2][dim3][l];
		    		
		    }
		    
		    System.out.println("a soma =" +somatorio);
		   
		   return somatorio;
		  }
	     
	
	 
	
	
public static void main(String args[]) throws IOException {

		// Realizando a leitura do arquivo binário
		DataInputStream input = new DataInputStream(new FileInputStream(new File("C:/Documents and Settings/Projeto_Estudo/data.dtb")));

		// Lendo as dimensões gravadas no binário
		int dim1 = 4; // dimensão fixa
		int dim2 = input.readInt(); // dimensão lida do arquivo binário
		int dim3 = input.readInt(); // dimensão lida do arquivo binário
		int dim4 = input.readInt(); // dimensão lida do arquivo binário
		
		// Exibo os valores de cada dimensão, só para verificar se esta "pegando" valor correto
		System.out.println("Dimensão1= " +dim1);
		System.out.println("Dimensão2= " +dim2);
		System.out.println("Dimensão3= " +dim3);
		System.out.println("Dimensão4= " +dim4);
		
		// Guardo os valores das respectivas matrizes	
		double [][][][] mat_modImag = criaMatriz4D(4, dim2, dim3, dim4, input);
		double [][][][] mat_conjImag = criaMatriz4D(4, dim2, dim3, dim4, input);
		float [][][] mat_modScatter = criaMatriz3D(dim2, dim3, dim4, input);
		float [][][] mat_conjScatter = criaMatriz3D(dim2, dim3, dim4, input);
		
		// Fechando a leitura
		input.close();
		
		
		// Imprime as posições das matrizes
		System.out.println(mat_modImag[0][0][16][16]); 
		System.out.println(mat_conjImag[0][0][19][16]);
		System.out.println(mat_modScatter[1][2][1]);
		System.out.println(mat_conjScatter[14][16][3]);
		
	}
	
	
	

    // Metodo para imprimir as matrizes
	private static void imprimeMatriz(double[][][][] matriz) {
		System.out.println("----");
		for (int i = 0; i < matriz.length; i++) {
			for (int j = 0; j < matriz[i].length; j++) {
				for (int k = 0; k < matriz[i][j].length; k++) {
					System.out.print("  ");
					for (int l = 0; l < matriz[i][j][k].length; l++) {
						//System.out.print(matriz[i][j][k][l] + " ");
					}
					System.out.println();
				}
				System.out.println("--");
			}
			System.out.println("----");
		}
	}

}