docs: public static DEigenpair computeEigenVector(DMatrixRMaj A , double eigenvalue )
      {
          if( A.numRows != A.numCols )
              throw new IllegalArgumentException("Must be a square matrix.");
  
          DMatrixRMaj M = new DMatrixRMaj(A.numRows,A.numCols);
  
          DMatrixRMaj x = new DMatrixRMaj(A.numRows,1);
          DMatrixRMaj b = new DMatrixRMaj(A.numRows,1);
  
          CommonOps_DDRM.fill(b, 1);
          
          // perturb the eigenvalue slightly so that its not an exact solution the first time
  //        eigenvalue -= eigenvalue*UtilEjml.EPS*10;
  
          double origEigenvalue = eigenvalue;
  
          SpecializedOps_DDRM.addIdentity(A,M,-eigenvalue);
  
          double threshold = NormOps_DDRM.normPInf(A)*UtilEjml.EPS;
  
          double prevError = Double.MAX_VALUE;
          boolean hasWorked = false;
  
          LinearSolverDense<DMatrixRMaj> solver = LinearSolverFactory_DDRM.linear(M.numRows);
  
          double perp = 0.0001;
  
          for( int i = 0; i < 200; i++ ) {
              boolean failed = false;
              // if the matrix is singular then the eigenvalue is within machine precision
              // of the true value, meaning that x must also be.
              if( !solver.setA(M) ) {
                  failed = true;
              } else {
                  solver.solve(b,x);
              }
  
              // see if solve silently failed
              if( MatrixFeatures_DDRM.hasUncountable(x)) {
                  failed = true;
              }
  
              if( failed ) {
                  if( !hasWorked ) {
                       // if it failed on the first trial try perturbing it some more
                      double val = i % 2 == 0 ? 1.0-perp : 1.0 + perp;
                      // maybe this should be turn into a parameter allowing the user
                      // to configure the wise of each step
  
                      eigenvalue = origEigenvalue * Math.pow(val,i/2+1);
                      SpecializedOps_DDRM.addIdentity(A,M,-eigenvalue);
                  } else {
                      // otherwise assume that it was so accurate that the matrix was singular
                      // and return that result
                      return new DEigenpair(eigenvalue,b);
                  }
              } else {
                  hasWorked = true;
                  
                  b.set(x);
                  NormOps_DDRM.normalizeF(b);
  
                  // compute the residual
                  CommonOps_DDRM.mult(M,b,x);
                  double error = NormOps_DDRM.normPInf(x);
  
                  if( error-prevError > UtilEjml.EPS*10) {
                      // if the error increased it is probably converging towards a different
                      // eigenvalue
  //                    CommonOps.set(b,1);
                      prevError = Double.MAX_VALUE;
                      hasWorked = false;
                      double val = i % 2 == 0 ? 1.0-perp : 1.0 + perp;
                      eigenvalue = origEigenvalue * Math.pow(val,1);
                  } else {
                      // see if it has converged
                      if(error <= threshold || Math.abs(prevError-error) <= UtilEjml.EPS)
                          return new DEigenpair(eigenvalue,b);
  
                      // update everything
                      prevError = error;
                      eigenvalue = VectorVectorMult_DDRM.innerProdA(b,A,b);
                  }
  
                  SpecializedOps_DDRM.addIdentity(A,M,-eigenvalue);
              }
          }
  
          return null;
      }