# Matrizen / Kommandozeilenparameter



## 3rdmuta (2. Dez 2012)

Hallo, 

erstmal einen schönen 1.Advent und dann auch schon zu meinem, für mich sehr großem ;( , Problem. 

Mein Programm soll bestimmte Matrix-Operationen durchführen und bei einer falsch gewählten Größe soll "null" zurück gegeben werden. Zum testen darf ich beliebige Matrizen verwenden und es soll sich auf Matrizen des Basistyps double beschränkt werden. Soweit so gut, die Matrizen lassen sich (m.E. richtig) berechnen...der Fehlermeldung habe ich ehrlich gesagt noch keine Aufmerksamkeit geschenkt, da ich es nicht einmal schaffe, einen Ansatz dafür zu finden, wie die Matrizen mit dem verwendeten Korrekturskript, bzw über die Kommandozeile "befüllt" werden sollen..?? Ich hoffe mir kann einer helfen  

Mein bisheriger Erfolg 

```
public static void main(String[] args)
        {
            double M1[][]  = { {1,2,3}, {4,5,6}, {7,8,9} };
            double M2 [][] = { {1,2,3}, {4,5,6}, {7,8,9} };
            double M [][]  = { {1,2,3}, {4,5,6}, {7,8,9} };
     
     int i,j;                   
     //double M1 = Double.parseDouble(args[0]);
     //double M2 = Double.parseDouble(args[0]);
     //double M  = Double.parseDouble(args[0]);
    
            double addition [][] = add(M1, M2);
                for(i = 0; i < addition.length; i++)
                {
                    for(j = 0; j < addition[0].length; j++)
                   
                        System.out.print(addition[j][i] + "  ");
                        System.out.println();
                        System.out.println();
                   
                         }   
                
                double subtract [][] = sub(M1, M2);
                    for(i = 0; i < subtract.length; i++)
                    {
                      for(j = 0; j < subtract[0].length; j++)
                        
                        System.out.print(subtract[j][i] + "  ");
                          System.out.println();
                          System.out.println();
                    }
                    
                double multiplication [][] = mul(M1,M2);
                      for(i = 0; i < multiplication.length; i++)
                      {
                          for(j = 0; j < multiplication[0].length; j++)
                 
                           System.out.print(multiplication[j][i] + "  ");                 
                         System.out.println();
                         System.out.println();
                      }
        
                 double transpose [][] = trans(M);    
                     for(i = 0; i < transpose.length; i++)
                     {
                         for(j = 0; j < transpose[0].length; j++)
                    
                        System.out.print(transpose[j][i] + "  ");    
                        System.out.println();
                        System.out.println();
                     }             
                     }
	

	private static double[][] add(double M1, double M2)
	{
	return null;
	}
		public static double[][] add(double[][] M1, double[][] M2)
		{
			//	System.out.println("Operation on matrix is addition:");   
			//	System.out.println();
            
    		double add[][] = new double[M1.length][M1[0].length];
    			for(int i = 0; i < add.length; i++)
    				for(int j = 0; j < add[0].length; j++)
    					add [i][j] = M1[i][j] + M2[i][j];

    			return add;
    	}    


	private static double[][] sub(double M1, double M2) 
	{
	return null;
	}             
		public static double[][] sub(double[][] M1, double[][] M2)
		{    
    		//	System.out.println("Operation on matrix is subtraction:"); 
    		//	System.out.println();

    	    double sub[][] = new double[M1.length][M1[0].length];
    			for(int i = 0; i < sub.length; i++)
    				for(int j = 0; j < sub[0].length; j++)
    					sub [i][j] = M1[i][j] - M2[i][j];

    			return sub;
		}


    private static double[][] mul(double M1, double M2) 
    {
    return null;
    }
    	public static double[][] mul(double[][] M1, double[][] M2)
    	{
 			//	System.out.println("Operation on matrix is multiplication:"); 
 			//	System.out.println();

    		double mul[][] = new double[M1.length][M1[0].length];
 				for(int i = 0; i < mul.length; i++)
 					for(int j = 0; j < mul[0].length; j++)
 						mul [i][j] = M1[i][j] * M2[i][j];

 				return mul;
    	}       


    private static double[][] trans(double M) 
    {
    return null;
    }				
    	public static double [][] trans(double[][] M) 
    	{
    		//	System.out.println("Operation on matrix is transpose:"); 
    		//	System.out.println();

    		double trans[][] = new double[M.length][M[0].length];
    			for(int i = 0; i < trans.length; i++)
    				for(int j = 0; j < trans[0].length; j++)
    					trans [j][i] = M [i][j]; 

    			return trans;
    	}
```

Die Sache ist die, ich hatte wegen der Kommandozeilengeschichte über das Wochenende so viel an meinem Code verändert, dass ich ich jetzt zumindest wieder auf dem Standpunkt bin, die Matrizen zu berechnen   die Methoden hatte ich ursprünglich mal dafür gedacht, die Matrizen auch einzeln aufrufen zu können...sind momentan aber iwie überflüssig...
Das Nennen der Matrixoperation hatte ich nur für mich gemacht, das ist nicht gefordert/erwünscht in der Aufg.stellung, daher als Kommentar markiert.
Ich komm einfach nich weiter, weil ich auch so wenig Ahnung habe und ja, google ist mein Freund  - aber der wollte mir in den letzten zwei Tagen einfach nicht helfen 

Lieben Dank schonmal im Voraus


----------



## Marco13 (2. Dez 2012)

Eine Methode wie
private static void print(double matrix[][]) ...
könnte praktisch sein.

Ansonsten müßtest du die eigentliche Frage nochmal genauer herausstellen... :bahnhof:


----------



## 3rdmuta (2. Dez 2012)

Die eigentliche Frage lautet, wie kann ich die Zahlen für die Matrizen durch die Kommandozeile eingeben. 

Bzw. villeicht verstehe ich ja auch etwas falsch, aber mein Programm wird durch ein Korrektur-Skript überprüft und innerhalb diesem sind bereits Matrizen gespeichert, anhand derer die Operationen getestet werden.

ich habe leider keine Ahnung wie ich meinem Programm zu verstehen gebe, dass es die Matrizen aus dem Skript, oder aus der Kommandozeile, verwenden soll.

ich wollte das erst mit

```
// double M1 = Double.parseDouble(args[0]);
    // double M2 = Double.parseDouble(args[0]);
    // double M  = Double.parseDouble(args[0]);
```

versuchen. Allerdings kam ich auf keinen grünen Zweig.
Dann dachte ich ich muss das ganze vielleicht in die Form bringen...

```
double[] M;
     M = new double (args[0]);
     
     double[] M1;
     M1 = new double (args[0]);
     
     double[] M2;
     M2 = new double (args[0]) ;
```
Aber da komm ich jetzt auch nicht weiter. Ich habe halt leider auch gar keine Programmiererfahrung...
Ich hoffe das hilft dir ein wenig weiter. 
Lieben Gruß


----------



## Marco13 (2. Dez 2012)

Ja, die eigentliche Eingabe kann man GROB mit sowas machen wie

```
Scanner sc = new Scanner(System.in);

System.out.println("rows: ");
int rows = sc.nextInt();

System.out.println("columns: ");
int cols = sc.nextInt();

matrix = new double[rows][cols];
for (int r=0; r<rows; r++)
{
    for (int c=0; c<cols; c++)
    {
        System.out.println("At "+r+" "+c+": ");
        matrix[r][c] = sc.nextDouble();
    }
}
```


----------



## 3rdmuta (2. Dez 2012)

ah, okay...das muss ich mir gleich genauer anschauen. 

Hatte es jetzt über diesen Weg versucht

```
int N = Integer.parseInt(args[0]);
    	 int O = Integer.parseInt(args[0]);
    	 int P = Integer.parseInt(args[0]);
    	 double M1 [][] = { {N,N,N}, {N,N,N}, {N,N,N} };
         double M2 [][] = { {O,O,O}, {O,O,O}, {O,O,O} };
         double M  [][] = { {P,P,P}, {P,P,P}, {P,P,P} };
```
bin mir aber sicher das stimmt nicht und rechnet mit den falchen Zahlen.


----------

