import java.io.File;
import java.util.ArrayList;
import java.util.Scanner;

/**
 *
 * @author wlk
 * sorry for no comments
 */
public class MyMatrix {
    public static final int SIZE = 3;
    private double[][] t;

    public MyMatrix(){
        t = new double[SIZE][SIZE];
        //t[0][0] = 0.0;
        this.reset();
    }

    public MyMatrix(File f){
        this();
        Scanner s = null;
        try{
            s = new Scanner(f);
        }
        catch(Exception e){
            System.err.println(s.next());
            e.printStackTrace();
        }
        for(int i = 0 ; i< SIZE; ++i){
            for(int j = 0; j < SIZE; ++j){
                t[i][j] = Double.valueOf(s.next());
               
                 System.out.println(t[i][j]);
            }
        }

    }

    public void reset(){
        for(int i = 0; i < SIZE; ++i){
            for(int j = 0; j < SIZE; ++j){
                if(i==j){
                    this.t[i][j] = 1.0;
                }
                else{
                    this.t[i][j] = 0.0;
                }
            }
        }
    }

    public MyMatrix add(MyMatrix A){
        MyMatrix T = new MyMatrix();
        for(int i = 0; i < SIZE; ++i){
            for(int j = 0; j < SIZE; ++j){
                T.t[i][j] = A.t[i][j] + t[i][j];
            }
        }
        return T;
    }

    public MyMatrix multiply(MyMatrix A){
        MyMatrix T = new MyMatrix();
        for(int i = 0; i < SIZE; ++i){
            for(int j = 0; j < SIZE; ++j){
                double tmp = 0;
                for(int k = 0; k < SIZE; ++k){
                    tmp += t[k][i] * A.t[j][k];
                }
                T.t[j][i] = tmp;
            }
        }
        return T;
    }
    
    public MyMatrix multiplyByNum(double n){
        MyMatrix T = new MyMatrix();
        for(int i = 0; i < SIZE; ++i){
            for(int j = 0; j < SIZE; ++j){
                T.t[i][j] = n*t[i][j];
            }
        }
        return T;
    }

    public ArrayList<Double> multiplyByVector(ArrayList<Double> list){
        ArrayList<Double> vect = new ArrayList<Double>();

        vect.add(list.get(0).doubleValue()*t[0][0]+list.get(1).doubleValue()*t[0][1]+list.get(2).doubleValue()*t[0][2]);
        vect.add(list.get(0).doubleValue()*t[1][0]+list.get(1).doubleValue()*t[1][1]+list.get(2).doubleValue()*t[1][2]);
        vect.add(list.get(0).doubleValue()*t[2][0]+list.get(1).doubleValue()*t[2][1]+list.get(2).doubleValue()*t[2][2]);
        return vect;
    }

    public MyMatrix invert(MyMatrix A){
        double d = det();
        if(d == 0){
            System.err.println("det = 0!!!");
            return null;
        }
        else{
            return transpose(cofactor(A)).multiplyByNum(1/d);
        }
    }

    public MyMatrix cofactor(MyMatrix A){
        MyMatrix T = new MyMatrix();
        T.t[0][0] = A.t[1][1]*A.t[2][2]-A.t[2][1]*A.t[1][2];
        T.t[0][1] = -(A.t[1][0]*A.t[2][2]-A.t[2][0]*A.t[1][2]);
        T.t[0][2] = A.t[1][0]*A.t[2][1]-A.t[2][0]*A.t[1][1];
        T.t[1][0] = -(A.t[0][1]*A.t[2][2]-A.t[2][1]*A.t[0][2]);
        T.t[1][1] = A.t[0][0]*A.t[2][2]-A.t[2][0]*A.t[0][2];
        T.t[1][2] = -(A.t[0][0]*A.t[2][1]-A.t[2][0]*A.t[0][1]);
        T.t[2][0] = A.t[0][1]*A.t[1][2]-A.t[1][1]*A.t[0][2];
        T.t[2][1] = -(A.t[0][0]*A.t[1][2]-A.t[1][0]*A.t[0][2]);
        T.t[2][2] = A.t[0][0]*A.t[1][0]-A.t[1][0]*A.t[0][1];
        return T;
    }
    

    public MyMatrix transpose(MyMatrix A){
        MyMatrix M = new MyMatrix();
        for(int i = 0; i < SIZE; ++i){
            for(int j = 0; j < SIZE; ++j){
                M.t[i][j] = A.t[j][i];
            }
        }
        return M;
    }

    public double getXY(int x, int y){
        return this.t[x][y];
    }

    public void setXY(int x, int y, double v){
        this.t[x][y] = v;
    }

    public String getXYS(int x, int y){
        return ((Double)t[x][y]).toString();
    }

    public double det(){
        return t[0][0]*t[1][1]*t[2][2]+t[1][0]*t[2][1]*t[0][2]+t[2][0]*t[0][1]*t[1][2]-t[1][0]*t[0][1]*t[2][2]-t[0][0]*t[2][1]*t[1][2]-t[2][0]*t[1][1]*t[0][2];
    }

    

}