public virtual bool process(FMatrixRMaj origA)
        {
            setup(origA);

            x1 = 0;
            x2 = origA.numRows - 1;

            while (implicitQR.numEigen < origA.numRows)
            {
                if (implicitQR.steps > implicitQR.maxIterations)
                {
                    return(false);
                }

                implicitQR.incrementSteps();

                if (x2 < x1)
                {
                    moveToNextSplit();
                }
                else if (x2 - x1 == 0)
                {
//                implicitQR.A.print();
                    implicitQR.addEigenAt(x1);
                    x2--;
                }
                else if (x2 - x1 == 1)
                {
//                implicitQR.A.print();
                    implicitQR.addComputedEigen2x2(x1, x2);
                    x2 -= 2;
                }
                else if (implicitQR.steps - implicitQR.lastExceptional > implicitQR.exceptionalThreshold)
                {
                    // see if the matrix blew up
                    if (float.IsNaN(implicitQR.A.get(x2, x2)))
                    {
                        return(false);
                    }

                    implicitQR.exceptionalShift(x1, x2);
                }
                else if (implicitQR.isZero(x2, x2 - 1))
                {
//                implicitQR.A.print();
                    implicitQR.addEigenAt(x2);
                    x2--;
                }
                else
                {
                    performIteration();
                }
            }

            return(true);
        }
        private bool findNextEigenvalue()
        {
            bool foundEigen = false;

            while (!foundEigen && _implicit.steps < _implicit.maxIterations)
            {
//            _implicit.A.print();
                _implicit.incrementSteps();

                if (x2 < x1)
                {
                    moveToNextSplit();
                }
                else if (x2 - x1 == 0)
                {
                    _implicit.addEigenAt(x1);
                    x2--;
                    indexVal++;
                    foundEigen = true;
                }
                else if (x2 - x1 == 1 && !_implicit.isReal2x2(x1, x2))
                {
                    _implicit.addComputedEigen2x2(x1, x2);
                    x2        -= 2;
                    indexVal  += 2;
                    foundEigen = true;
                }
                else if (_implicit.steps - _implicit.lastExceptional > _implicit.exceptionalThreshold)
                {
//                _implicit.A.print("%e");
                    //System.err.println("If it needs to do an exceptional shift then something went very bad.");
//                return false;
                    _implicit.exceptionalShift(x1, x2);
                    _implicit.lastExceptional = _implicit.steps;
                }
                else if (_implicit.isZero(x2, x2 - 1))
                {
                    // check for convergence
                    _implicit.addEigenAt(x2);
                    foundEigen = true;
                    x2--;
                    indexVal++;
                }
                else
                {
                    checkSplitPerformImplicit();
                }
            }
            return(foundEigen);
        }