// TestComplexMatrix.java

class TestComplexMatrix
{
  TestComplexMatrix()
  {
    int N = 4;
    Complex A[][]  = new Complex[N][N];
    Complex AI[][] = new Complex[N][N];
    Complex AT[][] = new Complex[N][N];
    double norm;

    System.out.println("TestComplexMatrix.java running");
    for(int i=0; i<N; i++)
      for(int j=0; j<N; j++)
        A[i][j] = new Complex(Math.max(i,j)+i,Math.max(i,j)+j);
    System.out.println("Matrix A");
    ComplexMatrix.print(A);
    ComplexMatrix.copy(A, AI);
    try
    {
      ComplexMatrix.invert(AI);
      System.out.println("inverse of A");
      ComplexMatrix.print(AI);
      ComplexMatrix.multiply(A, AI, AT);
      System.out.println("check A * A^-1 = I");
      ComplexMatrix.print(AT);
      System.out.println();
    }
    catch(Exception e)
    {
      System.out.println("invert caught ComplexMatrixException");
    }

    double YD[] = { 30.0 , 31.0 , 34.0 , 40.0 };
    Complex Y[] = new Complex[4];
    ComplexMatrix.fromDouble(YD, Y);
    Complex X[] = new Complex[N];
    Complex vector_result[] = new Complex[N];
    Complex vector_result_2[] = new Complex[N];
    double A2D[][] = {{ 1.0 , 2.0 , 3.0 } , { 4.0 , 5.0
       , 6.0 } , { 4.0 , 4.0 , 4.0 }};
    Complex A2[][] = new Complex[3][3];
    ComplexMatrix.fromDouble(A2D, A2);
    Complex A2I[][] = new Complex[3][3];
    double Y2D[] = { 1.5 , 2.5 , 3.5 };
    Complex Y2[] = new Complex[3];
    ComplexMatrix.fromDouble(Y2D, Y2);
    Complex X2[] = new Complex[3];
    Complex VR2[] = new Complex[3];
    Complex D;

    System.out.println("initial matrix A" );
    mat_init_1(A);
    ComplexMatrix.print(A);
    System.out.println("initial vector Y");
    ComplexMatrix.print(Y);
    System.out.println("solve equations Y = A X");
    ComplexMatrix.solve(A , Y , X);
    System.out.println("X = solution" );
    ComplexMatrix.print(X);
    System.out.println("check that solution gives back Y");
    ComplexMatrix.multiply(A, X, vector_result);
    ComplexMatrix.print(vector_result);
    System.out.println("check for zero A*X-Y vector");
    ComplexMatrix.subtract(vector_result, Y, vector_result_2);
    ComplexMatrix.print(vector_result_2);
    ComplexMatrix.copy(A, AI);
    ComplexMatrix.invert(AI);
    System.out.println("invert(A)" );

    ComplexMatrix.print(AI);
    System.out.println("check for solution vector, using invert(A) * Y");
    ComplexMatrix.multiply(AI, Y, vector_result);
    ComplexMatrix.print(vector_result);
    System.out.println( "check for zero A^-1*Y-X vector" );
    ComplexMatrix.subtract(vector_result, X, vector_result_2);
    ComplexMatrix.print(vector_result_2);
    ComplexMatrix.invert(AI);
    System.out.println("invert(AI) should be A");
    ComplexMatrix.print(AI);
    System.out.println("check for zero ((A^-1)^-1)-A check" );
    ComplexMatrix.subtract(A, AI, AI);
    ComplexMatrix.print(AI);
    norm=ComplexMatrix.normFro(AI);
    System.out.println("norm of ((A^-1)^-1)-A "+norm);
    System.out.println();

    System.out.println("initial matrix A2");
    ComplexMatrix.print(A2);
    System.out.println("initial vector Y2");
    ComplexMatrix.print(Y2);
    System.out.println( "solving equations" );
    ComplexMatrix.solve(A2 , Y2 , X2);
    System.out.println( "X2 = solution of Y2=A2 X2" );
    ComplexMatrix.print(X2);
    System.out.println("check that solution gives back Y2");
    ComplexMatrix.multiply(A2, X2, VR2);
    ComplexMatrix.print(VR2);
    System.out.println("check for zero vector");
    ComplexMatrix.subtract(VR2, Y2, VR2);
    ComplexMatrix.print(VR2);
    ComplexMatrix.copy(A2, A2I);
    ComplexMatrix.invert(A2I);
    System.out.println( "expect singular matrix \n" );
    System.out.println();

    System.out.println("D = determinant(A)");
    D = ComplexMatrix.determinant(A);
    System.out.println("D= "+D);
    System.out.println( "D=determinant(A2)");
    D = ComplexMatrix.determinant(A2);
    System.out.println("D= "+D);
    System.out.println();

    double AE[][] = {{1.0, 1.0, 1.0, 1.0},  {1.0, 2.0,  3.0,  4.0},
                     {1.0, 3.0, 6.0, 10.0}, {1.0, 4.0, 10.0, 20.0}};
    double VE[][] = new double[4][4];
    double YE[]   = new double[4];
    System.out.println("eigenvalues");
    Matrix.eigenvalues(AE, VE, YE);
    Matrix.eigenCheck(AE, VE, YE);

    Complex E3R[] = { new Complex(1.0,1.0), new Complex(-1.0,-3.0),
                    new Complex(2.0,-2.0), new Complex(3.0,-1.0)};
    Complex E3PV[] = new Complex[5];
    Complex E3C[] = new Complex[5]; // normalized coefficients
    ComplexMatrix.fromRoots(E3R,E3C);
    Complex E3[][] = new Complex[4][4];
    ComplexMatrix.zero(E3);
    for(int i=0; i<4; i++)
    {
      E3[0][i] = E3C[i].negate();
      if(i>0) E3[i][i-1] = new Complex(1.0,0.0);
    }
    Complex E3V[][] = new Complex[4][4];
    Complex E3Y[]   = new Complex[4];
    System.out.println("eigenvalues from polynomial");
    ComplexMatrix.eigenvalues(E3, E3V, E3Y);
    ComplexMatrix.eigenCheck(E3, E3V, E3Y);

    double XND[] = {1.25, 0.02, -5.15, 0.0};
    Complex XN[] = new Complex[4];
    ComplexMatrix.fromDouble(XND, XN);
    System.out.println("norm1="+ComplexMatrix.norm1(XN));
    System.out.println("norm2="+ComplexMatrix.norm2(XN));
    System.out.println("normInf="+ComplexMatrix.normInf(XN));
    System.out.println();

    double AND[][] = {{5.0, -5.0, -7.0}, {-4.0, 2.0, -4.0}, {-7.0, -4.0, 5.0}};
    Complex AN[][] = new Complex[3][3];
    ComplexMatrix.fromDouble(AND, AN);
    System.out.println("norm1="+ComplexMatrix.norm1(AN));
    System.out.println("norm2="+ComplexMatrix.norm2(AN));
    System.out.println("normInf="+ComplexMatrix.normInf(AN));
    System.out.println("normFro="+ComplexMatrix.normFro(AN));
    System.out.println();

    Complex II[][] = new Complex[3][3];
    ComplexMatrix.identity(II);
    System.out.println("identity matrix");
    ComplexMatrix.print(II);
    ComplexMatrix.zero(II);
    System.out.println("zero matrix");
    ComplexMatrix.print(II);
    Complex VV[] = new Complex[3];
    ComplexMatrix.unitVector(VV,1);
    System.out.println("unit vector [1]");
    ComplexMatrix.print(VV);
    ComplexMatrix.zero(VV);
    System.out.println("zero vector");
    ComplexMatrix.print(VV);

    System.out.println("TestComplexMatrix finished");
  } // end constructor TestComplexMatrix

  //  test functions used locally
  //
  static void mat_init_1(Complex B[][])
  {
    int i, j;
    int ni=B.length;
    int nj=B[0].length;

    for(i=0; i<ni; i++)
    {
      for(j=0; j<nj; j++)
      {
        if( i > j )
          B[i][j] = new Complex((double)(i+1),(double)(j+1));
        else
          B[i][j] = new Complex((double)(j+1),(double)(i+1));
      }
    }
  } // end mat_init_1

  public static void main (String[] args) // "main" required
  {
    new TestComplexMatrix(); // construct and execute
  }
} // end class TestComplexMatrix